home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume90 / aplictns / listplot / part02 < prev    next >
Internet Message Format  |  1990-08-23  |  58KB
  1. Path: abcfd20.larc.nasa.gov!amiga-request
  2. From: amiga-request@abcfd20.larc.nasa.gov (Amiga Sources/Binaries Moderator)
  3. Subject: v90i243: ListPlot - 2d plotting program, Part02/03
  4. Reply-To: Anthony M. Richardson <amr@dukee.egr.duke.edu>
  5. Newsgroups: comp.sources.amiga
  6. Message-ID: <comp.sources.amiga:v90i243@abcfd20.larc.nasa.gov>
  7. Date: 23 Aug 90 01:03:37 GMT
  8. Approved: tadguy@uunet.UU.NET (Tad Guy)
  9. X-Mail-Submissions-To: amiga@uunet.uu.net
  10. X-Post-Discussions-To: comp.sys.amiga
  11.  
  12. Submitted-by: Anthony M. Richardson <amr@dukee.egr.duke.edu>
  13. Posting-number: Volume 90, Issue 243
  14. Archive-name: applications/listplot/part02
  15.  
  16. #!/bin/sh
  17. # This is a shell archive.  Remove anything before this line, then unpack
  18. # it by saving it into a file and typing "sh file".  To overwrite existing
  19. # files, type "sh file -c".  You can also feed this as standard input via
  20. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  21. # will see the following message at the end:
  22. #        "End of archive 2 (of 3)."
  23. # Contents:  Csrc/ListPlot.c Csrc/get_args.c docs/ListPlot.uu
  24. # Wrapped by tadguy@abcfd20 on Wed Aug 22 21:03:21 1990
  25. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  26. if test -f 'Csrc/ListPlot.c' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'Csrc/ListPlot.c'\"
  28. else
  29. echo shar: Extracting \"'Csrc/ListPlot.c'\" \(19564 characters\)
  30. sed "s/^X//" >'Csrc/ListPlot.c' <<'END_OF_FILE'
  31. X/*
  32. X * ListPlot.c
  33. X *
  34. X * Yet another plotting filter.
  35. X *
  36. X */
  37. X#include <stdio.h>
  38. X#include <errno.h>
  39. Xextern int errno;
  40. X#include <assert.h>
  41. X#include <string.h>
  42. X#include <ctype.h>
  43. X#include <signal.h>
  44. X#include "datatypes.h"
  45. X
  46. Xvoid    ErrorExit();
  47. Xchar    *calloc();
  48. X
  49. X/* initializations    */
  50. Xchar    *Usage[] = {
  51. X    "Usage: ListPlot [Options]\n",
  52. X    0
  53. X};
  54. Xchar    *Function[] = {
  55. X    "Function: Yet another plotting filter. For help, enter \"ListPlot help\".\n\tFor more verbose help, enter \"ListPlot Verbose=on help=all\".\n",
  56. X    "\n",
  57. X    "\tListPlot supports a number of different devices.\n",
  58. X    "\n",
  59. X    "\tListPlot reads from stdin and writes to stdout unless input and/or\n",
  60. X    "\toutput files are specified on the command line.\n",
  61. X    "\tThe program accepts a file of n-tuples.  Each tuple consists of\n",
  62. X    "\ta sequence of space separated numbers terminated with a newline.\n",
  63. X    "\tThe first element of each tuple is assumed to be the independent\n",
  64. X    "\tvariable.  Each remaining element is plotted against the first to\n",
  65. X    "\tproduce n-1 curves.\n",
  66. X    "\n",
  67. X    "\tListPlot takes a number of command line arguments that may be\n",
  68. X    "\tused to control the appearance of the plots.\n",
  69. X    "\tFor a list of the arguments enter:\n",
  70. X    "\t\tListPlot Help=All.\n",
  71. X    "\n",
  72. X    "\t'Boolean' values accept values such as true, false,\n",
  73. X    "\tyes, no, on, and off. (ex. PlotColor=yes)\n",
  74. X    "\n",
  75. X    "\t'String' values expect the strings to entered as\n",
  76. X    "\tindicated and is case sensitive. (ex. Domain=All)\n",
  77. X    "\n",
  78. X    "\t'Dbl' values expect real numbers. (ex. AspectRatio=1.0)\n",
  79. X    "\n",
  80. X    "\t'Interval' values expect a pair of comma separated reals.\n",
  81. X    "\t\t(ex. Range=-1.0,3.0)\n",
  82. X    "\n",
  83. X    "\t'Set' values expect a list of comma separated elements enclosed in\n",
  84. X    "\tcurly braces ({}). (ex. LineStyle={MS,MMS,MSmmS})\n",
  85. X    "\n",
  86. X    "\tThe title and label variables accept strings that include\n",
  87. X    "\tthe following control sequences:\n",
  88. X    "\t\t#u: move up to superscript position (ended with #d)\n",
  89. X    "\t\t#d: move down to subscript position (ended with #u)\n",
  90. X    "\t\t#b: backspace to allow overprinting\n",
  91. X    "\t\t##: the number symbol\n",
  92. X    "\t\t#+: toggle overline mode\n",
  93. X    "\t\t#-: toggle underline mode\n",
  94. X    "\t\t#gx: Greek letter corresponding to Roman letter x\n",
  95. X    "\n",
  96. X    0
  97. X};
  98. X
  99. Xbool    GraphicsInProgress = FALSE;
  100. X
  101. X
  102. X/* argument definitions    */
  103. X/* GoldenRatio = (1+Sqrt(5))/2    */
  104. X#define    GOLDENRATIO    1.6180339887499
  105. X#define ASPECTRATIO    1.0/GOLDENRATIO
  106. Xchar    *H_AngularUnit[] = {
  107. X    "\t'AngularUnit' specifies the angular unit of measure\n",
  108. X    "\tused for polar plots.  For angles in radians use\n",
  109. X    "\t\tAngularUnit=radians\n",
  110. X    (char *)NULL
  111. X};
  112. XVALUE    V_AngularUnit;
  113. XARGDEF    A_AngularUnit = {
  114. X        &V_AngularUnit,            /* variable    */
  115. X        "AngularUnit",            /* ID        */
  116. X        "degrees|radians",        /* options    */
  117. X        "string|string",        /* format    */
  118. X        "degrees",            /* default    */
  119. X        "string",            /* Default type */
  120. X        H_AngularUnit
  121. X    };
  122. Xchar    *H_AnnotationScale[] = {
  123. X    "\t'AnnotationScale' controls the size of the characters\n",
  124. X    "\tused to annotate the axises.\n",
  125. X    (char *)NULL
  126. X};
  127. XVALUE    V_AnnotationScale;
  128. XARGDEF    A_AnnotationScale = {
  129. X        &V_AnnotationScale,        /* variable    */
  130. X        "AnnotationScale",        /* ID        */
  131. X        "dbl",                /* options    */
  132. X        "dbl",                /* format    */
  133. X        "0.50",                /* default    */
  134. X        "dbl",                /* Default type */
  135. X        H_AnnotationScale
  136. X    };
  137. Xchar    *H_AspectRatio[] = {
  138. X    "\t'AspectRatio' controls the relative lengths of the vertical to\n",
  139. X    "\thorizontal axes.  The default is 1.0/GoldenRatio.\n",
  140. X    "\t\tAspectRatio=0.618\n",
  141. X    "\tIf set this value overrides the value of 'ViewPort'.\n",
  142. X    (char *)NULL
  143. X};
  144. XVALUE    V_AspectRatio;
  145. XARGDEF    A_AspectRatio = {
  146. X        &V_AspectRatio,            /* variable    */
  147. X        "AspectRatio",            /* ID        */
  148. X        "dbl|Automatic",        /* options    */
  149. X        "dbl|string",            /* format    */
  150. X        "0.61803399",            /* default    */
  151. X        "dbl",                /* Default type */
  152. X        H_AspectRatio
  153. X    };
  154. Xchar    *H_Boxed[] = {
  155. X    "\t'Boxed' adds axes to the edges of the plot.\n",
  156. X    "\tIf 'Boxed is given a boolean value then axes are placed on\n",
  157. X    "\tall of the edges.  If 'Boxed' is given a string consisting\n",
  158. X    "\tof one or more of 't','b','r','l' then axes are added to\n",
  159. X    "\ttop, bottom, right and left edges respectively.\n",
  160. X    (char *)NULL
  161. X};
  162. XVALUE    V_Boxed;
  163. XARGDEF    A_Boxed = {
  164. X        &V_Boxed,            /* variable    */
  165. X        "Boxed",            /* ID        */
  166. X        "boolean|*",            /* options    */
  167. X        "boolean|string",            /* format    */
  168. X        "yes",                /* default    */
  169. X        "boolean",            /* Default type */
  170. X        H_Boxed
  171. X    };
  172. Xchar    *H_Domain[] = {
  173. X    "\t'Domain' may be used to specify the bounds on the X axis.\n",
  174. X    (char *)NULL
  175. X};
  176. XVALUE    V_Domain;
  177. XARGDEF    A_Domain = {
  178. X        &V_Domain,                /* variable    */
  179. X        "Domain",                /* ID        */
  180. X        "interval|All|Automatic",        /* options    */
  181. X        "interval|string|string",        /* format    */
  182. X        "All",                    /* default    */
  183. X        "string",                /* Default type */
  184. X        H_Domain
  185. X    };
  186. Xchar    *H_Gridding[] = {
  187. X    "\t'Gridding' puts a grid on the plot.\n",
  188. X    (char *)NULL
  189. X};
  190. XVALUE    V_Gridding;
  191. XARGDEF    A_Gridding = {
  192. X        &V_Gridding,            /* variable    */
  193. X        "Gridding",            /* ID        */
  194. X        "boolean",            /* options    */
  195. X        "boolean",            /* format    */
  196. X        "no",                /* default    */
  197. X        "boolean",            /* Default type */
  198. X        H_Gridding
  199. X    };
  200. X
  201. X/* N.B. Help is treated differently than other variables and its
  202. X * arguments should only be of type "string"!
  203. X */
  204. Xchar    *H_Help[] = {
  205. X    "\t'Help' provides some descriptive text for the user-settable\n",
  206. X    "\tplotting variables.  If the variable 'Verbose' is set then\n",
  207. X    "\tan extended description is provided. To set verbose enter\n",
  208. X    "\t\tListPlot Verbose=yes Help=[variable name | All].\n",
  209. X    (char *)NULL
  210. X};
  211. XVALUE    V_Help;
  212. XARGDEF    A_Help = {
  213. X        &V_Help,            /* variable    */
  214. X        "Help",                /* ID        */
  215. X        "All|all|*",            /* options    */
  216. X        "string|string|string",        /* format    */
  217. X        "All",                /* default    */
  218. X        "string",            /* Default type */
  219. X        H_Help
  220. X    };
  221. Xchar    *H_LabelScale[] = {
  222. X    "\t'LabelScale' specifies the relative size of the vertical and\n",
  223. X    "\thorizontal axis labels.  The typical range is [0.5 - 2.0].\n",
  224. X    (char *)NULL
  225. X};
  226. XVALUE    V_LabelScale;
  227. XARGDEF    A_LabelScale = {
  228. X        &V_LabelScale,            /* variable    */
  229. X        "LabelScale",            /* ID        */
  230. X        "dbl",                /* options    */
  231. X        "dbl",                /* format    */
  232. X        "0.85",                /* default*/
  233. X        "dbl",                /* Default type */
  234. X        H_LabelScale
  235. X    };
  236. Xchar    *H_LineColor[] = {
  237. X    "\t'LineColor' may be used to specify a list of line colors for\n",
  238. X    "\tplots with multiple curves if this feature is supported for\n",
  239. X    "\ta particular output device.\n",
  240. X    (char *)NULL
  241. X};
  242. XVALUE    V_LineColor;
  243. XARGDEF    A_LineColor = {
  244. X        &V_LineColor,            /* variable    */
  245. X        "LineColor",            /* ID        */
  246. X        "set",                /* options    */
  247. X        "set",                /* format    */
  248. X        "{Black,Red,Green,Blue,Yellow}",    /* default*/
  249. X        "set",                /* Default type */
  250. X        H_LineColor
  251. X    };
  252. Xchar    *H_LineStyle[] = {
  253. X    "\t'LineStyle' may be used to specify a list of line styles for\n",
  254. X    "\tplots with multiple curves.  Each linestyle is specified as\n",
  255. X    "\ta sequence of pen down... pen up elements. The elements are encoded\n",
  256. X    "\tusing the following characters to indicate element lengths:\n",
  257. X    "\t\t'm':\t250 micron mark\n",
  258. X    "\t\t'M':\t4 m's or a 1mm mark\n",
  259. X    "\t\t's':\t250 micron space\n",
  260. X    "\t\t'S':\t4 s's or a 1mm space\n",
  261. X    "\n",
  262. X    "\tFor example, a set of line styles might be indicated\n",
  263. X    "\t\tLineStyle={MS,MMSS,MMSmmS,mmS,mmSmmSMMS}\n",
  264. X    (char *)NULL
  265. X};
  266. XVALUE    V_LineStyle;
  267. XARGDEF    A_LineStyle = {
  268. X        &V_LineStyle,            /* variable    */
  269. X        "LineStyle",            /* ID        */
  270. X        "set",                /* options    */
  271. X        "set",                /* format    */
  272. X        "{MS,MMSS,MMSmmS,mmS,mmSmmSMMS}",/*default*/
  273. X        "set",                /* Default type */
  274. X        H_LineStyle
  275. X    };
  276. Xchar    *H_Origin[] = {
  277. X    "\tThe 'Origin' option is not yet implemented. It is intended\n",
  278. X    "\tthat this feature beused to specify the origin of the plot.\n",
  279. X    (char *)NULL
  280. X};
  281. XVALUE    V_Origin;
  282. XARGDEF    A_Origin = {
  283. X        &V_Origin,            /* variable    */
  284. X        "Origin",            /* ID        */
  285. X        "interval|Automatic|Median",    /* options    */
  286. X        "interval|string|string",    /* format    */
  287. X        "Automatic",            /* default    */
  288. X        "string",            /* Default type */
  289. X        H_Origin
  290. X    };
  291. Xchar    *H_PlotColor[] = {
  292. X    "\t'PlotColor' if TRUE causes the plot to generated in color if this\n",
  293. X    "\tfeature is supported on a particular output device.\n",
  294. X    (char *)NULL
  295. X};
  296. XVALUE    V_PlotColor;
  297. XARGDEF    A_PlotColor = {
  298. X        &V_PlotColor,            /* variable    */
  299. X        "PlotColor",            /* ID        */
  300. X        "boolean",            /* options    */
  301. X        "boolean",            /* format    */
  302. X        "no",                /* default    */
  303. X        "boolean",            /* Default type */
  304. X        H_PlotColor
  305. X    };
  306. Xchar    *H_PlotDevice[] = {
  307. X    "\t'PlotDevice' specifies output device type.\n",
  308. X    (char *)NULL
  309. X};
  310. XVALUE    V_PlotDevice;
  311. XARGDEF    A_PlotDevice = {
  312. X        &V_PlotDevice,            /* variable    */
  313. X        "PlotDevice",            /* ID        */
  314. X        "amiga|printer|iff|hp|aegis|postscript",/* options    */
  315. X        "string|string|string|string|string|string",/* format    */
  316. X        "amiga",            /* default    */
  317. X        "string",            /* Default type */
  318. X        H_PlotDevice
  319. X    };
  320. Xchar    *H_PlotJoined[] = {
  321. X    "\t'PlotJoined' is set connects each data point with a line in the\n",
  322. X    "\tcurrent line style. (ex PlotJoined=on )\n",
  323. X    (char *)NULL
  324. X};
  325. XVALUE    V_PlotJoined;
  326. XARGDEF    A_PlotJoined = {
  327. X        &V_PlotJoined,            /* variable    */
  328. X        "PlotJoined",            /* ID        */
  329. X        "boolean",            /* options    */
  330. X        "boolean",            /* format    */
  331. X        "yes",                /* default    */
  332. X        "boolean",            /* Default type */
  333. X        H_PlotJoined
  334. X    };
  335. Xchar    *H_PlotPoints[] = {
  336. X    "\t'PlotPoints' if set causes symbols to be plotted in the current\n",
  337. X    "\tsymbol style at each data point. (ex. PlotPoints=true )\n",
  338. X    (char *)NULL
  339. X};
  340. XVALUE    V_PlotPoints;
  341. XARGDEF    A_PlotPoints = {
  342. X        &V_PlotPoints,            /* variable    */
  343. X        "PlotPoints",            /* ID        */
  344. X        "boolean",            /* options    */
  345. X        "boolean",            /* format    */
  346. X        "false",            /* default    */
  347. X        "boolean",            /* Default type */
  348. X        H_PlotPoints
  349. X    };
  350. Xchar    *H_PlotTitle[] = {
  351. X    "\t'PlotTitle' takes the plot title as an argument.\n",
  352. X    "\tGreek symbols may be specified by preceding a character by\n",
  353. X    "\t'#g'. Superscripts and subscripts may be specified using\n",
  354. X    "\t'#u', '#d' respectively.\n",
  355. X    (char *)NULL
  356. X};
  357. XVALUE    V_PlotTitle;
  358. XARGDEF    A_PlotTitle = {
  359. X        &V_PlotTitle,            /* variable    */
  360. X        "PlotTitle",            /* ID        */
  361. X        "*",                /* options    */
  362. X        "string",            /* format    */
  363. X        "",                /* default    */
  364. X        "string",            /* Default type */
  365. X        H_PlotTitle
  366. X    };
  367. Xchar    *H_PlotType[] = {
  368. X    "\t'PlotType' specifies the 'graph paper' upon which the plot is drawn.\n",
  369. X    "\tThe current implementation plots in\n",
  370. X    "\t\tlinear-linear,\n",
  371. X    "\t\tlog-linear,\n",
  372. X    "\t\tlinear-log,\n",
  373. X    "\t\tlog-log, and\n",
  374. X    "\t\tpolar\n",
  375. X    "\tformats.\n",
  376. X    "\tFor the log type plots, the log of the data is computed\n",
  377. X    "\tby ListPlot.\n",
  378. X    "\tFor polar plots, see also 'AngularUnit' and 'PolarVariable'.\n",
  379. X    (char *)NULL
  380. X};
  381. XVALUE    V_PlotType;
  382. XARGDEF    A_PlotType = {
  383. X        &V_PlotType,            /* variable    */
  384. X        "PlotType",            /* ID        */
  385. X        "linlin|loglin|linlog|loglog|polar",/* options    */
  386. X        "string|string|string|string|string",/* format    */
  387. X        "linlin",            /* default    */
  388. X        "string",            /* Default type */
  389. X        H_PlotType
  390. X    };
  391. Xchar    *H_PointScale[] = {
  392. X    "\t'PointScale' controls the relative size of the data point symbols\n",
  393. X    "\twhen data point symbols are being plotted.\n",
  394. X    (char *)NULL
  395. X};
  396. XVALUE    V_PointScale;
  397. XARGDEF    A_PointScale = {
  398. X        &V_PointScale,            /* variable    */
  399. X        "PointScale",            /* ID        */
  400. X        "dbl",                /* options    */
  401. X        "dbl",                /* format    */
  402. X        "1.0",                /* default    */
  403. X        "dbl",                /* Default type */
  404. X        H_PointScale
  405. X    };
  406. Xchar    *H_PointSymbol[] = {
  407. X    "\t'PointSymbol' specifies a list of symbols to be used when plotting\n",
  408. X    "\tdata points. The symbols types are encoded as integers.\n",
  409. X    "\tSee the PLPLOT library documentation to find the symbols\n",
  410. X    "\tavailable.\n",
  411. X    (char *)NULL
  412. X};
  413. XVALUE    V_PointSymbol;
  414. XARGDEF    A_PointSymbol = {
  415. X        &V_PointSymbol,            /* variable    */
  416. X        "PointSymbol",            /* ID        */
  417. X        "Automatic|set",        /* options    */
  418. X        "string|set",            /* format    */
  419. X        "Automatic",            /* default    */
  420. X        "string",            /* Default type */
  421. X        H_PointSymbol
  422. X    };
  423. Xchar    *H_PolarVariable[] = {
  424. X    "\t'PolarVariable' for polar plots is used to specify\n",
  425. X    "\twhether the independent variable is angular or radial.\n",
  426. X    (char *)NULL
  427. X};
  428. XVALUE    V_PolarVariable;
  429. XARGDEF    A_PolarVariable = {
  430. X        &V_PolarVariable,        /* variable    */
  431. X        "PolarVariable",        /* ID        */
  432. X        "angle|radius",            /* options    */
  433. X        "string|string",        /* format    */
  434. X        "angle",            /* default    */
  435. X        "string",            /* Default type */
  436. X        H_PolarVariable
  437. X    };
  438. Xchar    *H_Orientation[] = {
  439. X    "\t'Orientation' controls whether the plot is displayed in\n",
  440. X    "\tlandscape or portrait orientation.\n",
  441. X    (char *)NULL
  442. X};
  443. XVALUE    V_Orientation;
  444. XARGDEF    A_Orientation = {
  445. X        &V_Orientation,                /* variable    */
  446. X        "Orientation",                /* ID        */
  447. X        "portrait|landscape",            /* options    */
  448. X        "string|string",            /* format    */
  449. X        "landscape",                /* default    */
  450. X        "string",                /* Default type */
  451. X        H_Orientation
  452. X    };
  453. Xchar    *H_Range[] = {
  454. X    "\t'Range' specifies the y axis bounds. (ex. Range=-1,1 )\n",
  455. X    (char *)NULL
  456. X};
  457. XVALUE    V_Range;
  458. XARGDEF    A_Range = {
  459. X        &V_Range,                /* variable    */
  460. X        "Range",                /* ID        */
  461. X        "interval|All|Automatic",        /* options    */
  462. X        "interval|string|string",        /* format    */
  463. X        "All",                    /* default    */
  464. X        "string",                /* Default type */
  465. X        H_Range
  466. X    };
  467. Xchar    *H_SubPages[] = {
  468. X    "\t'SubPages' specifies the number of plots on a pages.\n",
  469. X    "\tThis is a vestige of PLPLOT and I am not sure this has any use\n",
  470. X    "\twithin the context of 'ListPlot.  It might be useful for\n",
  471. X    "\tcontrolling the size of the plots but the 'ViewPort' might be\n",
  472. X    "\ta more direct solution.\n",
  473. X    (char *)NULL
  474. X};
  475. XVALUE    V_SubPages;
  476. XARGDEF    A_SubPages = {
  477. X        &V_SubPages,                /* variable    */
  478. X        "SubPages",                /* ID        */
  479. X        "interval",                /* options    */
  480. X        "interval",                /* format    */
  481. X        "1.0,1.0",                /* default    */
  482. X        "interval",                /* Default type */
  483. X        H_SubPages
  484. X    };
  485. Xchar    *H_SupplyAbscissa[] = {
  486. X    "\t'SupplyAbscissa' if set causes ListPlot to supply a value for\n",
  487. X    "\tthe independent variable.\n",
  488. X    (char *)NULL
  489. X};
  490. XVALUE    V_SupplyAbscissa;
  491. XARGDEF    A_SupplyAbscissa = {
  492. X        &V_SupplyAbscissa,            /* variable    */
  493. X        "SupplyAbscissa",            /* ID        */
  494. X        "boolean",                /* options    */
  495. X        "boolean",                /* format    */
  496. X        "no",                    /* default    */
  497. X        "boolean",                /* Default type */
  498. X        H_SupplyAbscissa
  499. X    };
  500. Xchar     *H_TitleScale[] = {
  501. X    "\t'TitleScale' controls the relative size of the title text.\n",
  502. X    (char *)NULL
  503. X};
  504. XVALUE    V_TitleScale;
  505. XARGDEF    A_TitleScale = {
  506. X        &V_TitleScale,                /* variable    */
  507. X        "TitleScale",                /* ID        */
  508. X        "dbl",                    /* options    */
  509. X        "dbl",                    /* format    */
  510. X        "1.0",                    /* default    */
  511. X        "dbl",                    /* Default type */
  512. X        H_TitleScale
  513. X    };
  514. Xchar    *H_UseInputFile[] = {
  515. X    "\t'UseInputFile' permits the specification of an input file if\n",
  516. X    "\tyou would rather not use stdin.\n",
  517. X    (char *)NULL
  518. X};
  519. XVALUE    V_UseInputFile;
  520. XARGDEF    A_UseInputFile = {
  521. X        &V_UseInputFile,        /* variable    */
  522. X        "UseInputFile",            /* ID        */
  523. X        "*",                /* options    */
  524. X        "string",            /* format    */
  525. X        "",                /* default    */
  526. X        "string",            /* Default type */
  527. X        H_UseInputFile
  528. X    };
  529. Xchar    *H_UseOutputFile[] = {
  530. X    "\t'UseOutputFile' permits the specification of an output file if\n",
  531. X    "\tyou would rather not use stdout.\n",
  532. X    (char *)NULL
  533. X};
  534. XVALUE    V_UseOutputFile;
  535. XARGDEF    A_UseOutputFile = {
  536. X        &V_UseOutputFile,        /* variable    */
  537. X        "UseOutputFile",        /* ID        */
  538. X        "*",                /* options    */
  539. X        "string",            /* format    */
  540. X        "",                /* default    */
  541. X        "string",            /* Default type */
  542. X        H_UseOutputFile
  543. X    };
  544. X/* Not used.  V_AspectRatio may be used to control viewport in a nicer way */
  545. Xchar    *H_Verbose[] = {
  546. X    "\t'Verbose' if set causes extended messaging.\n",
  547. X    (char *)NULL
  548. X};
  549. XVALUE    V_Verbose;
  550. XARGDEF    A_Verbose = {
  551. X        &V_Verbose,            /* variable    */
  552. X        "Verbose",            /* ID        */
  553. X        "boolean",            /* options    */
  554. X        "boolean",            /* format    */
  555. X        "off",                /* default    */
  556. X        "boolean",            /* Default type */
  557. X        H_Verbose
  558. X    };
  559. Xchar    *H_ViewPort[] = {
  560. X    "\t'ViewPort' allows control over the size of a plot. Takes\n",
  561. X    "\ta viewing rectangle diagonal as an argument.\n",
  562. X    "\t\t(ex. ViewPort=\\{0.1,0.3, 0.9,0.6\\} )\n",
  563. X    (char *)NULL
  564. X};
  565. XVALUE    V_ViewPort;
  566. XARGDEF    A_ViewPort = {
  567. X        &V_ViewPort,            /* variable    */
  568. X        "ViewPort",            /* ID        */
  569. X        "rect",                /* options    */
  570. X        "rect",                /* format    */
  571. X        "{0.1,0.1,0.9,0.9}",        /* default    */
  572. X        "rect",                /* Default type */
  573. X        H_ViewPort
  574. X    };
  575. Xchar    *H_XLabel[] = {
  576. X    "\t'XLabel' specifies X axis label.  Greek characters may be included\n",
  577. X    "\tby preceding the character with '#g'.  Superscripts and subscripts\n",
  578. X    "\tmay be included using '#u' and '#d' control sequences respectively.\n",
  579. X    (char *)NULL
  580. X};
  581. XVALUE    V_XLabel;
  582. XARGDEF    A_XLabel = {
  583. X        &V_XLabel,            /* variable    */
  584. X        "XLabel",            /* ID        */
  585. X        "*",                /* options    */
  586. X        "string",            /* format    */
  587. X        "",                /* default    */
  588. X        "string",            /* Default type */
  589. X        H_XLabel
  590. X    };
  591. Xchar    *H_XTick[] = {
  592. X    "\t'XTick' controls the spacing of major axis ticks and the number\n",
  593. X    "\tof minor subdivisions. (ex. XTick=0.1,10 indicates major ticks at\n",
  594. X    "\tunits of 0.1 with 10 minor subdivisions.)\n",
  595. X    (char *)NULL
  596. X};
  597. XVALUE    V_XTick;
  598. XARGDEF    A_XTick = {
  599. X        &V_XTick,            /* variable    */
  600. X        "XTick",            /* ID        */
  601. X        "Automatic|interval",        /* options    */
  602. X        "string|interval",        /* format    */
  603. X        "Automatic",            /* default    */
  604. X        "string",            /* Default type */
  605. X        H_XTick
  606. X    };
  607. Xchar    *H_YLabel[] = {
  608. X    "\t'YLabel' specifies Y axis label.  Greek characters may be included\n",
  609. X    "\tby preceding the character with '#g'.  Superscripts and subscripts\n",
  610. X    "\tmay be included using '#u' and '#d' control sequences respectively.\n",
  611. X    (char *)NULL
  612. X};
  613. XVALUE    V_YLabel;
  614. XARGDEF    A_YLabel = {
  615. X        &V_YLabel,            /* variable    */
  616. X        "YLabel",            /* ID        */
  617. X        "*",                /* options    */
  618. X        "string",            /* format    */
  619. X        "",                /* default    */
  620. X        "string",            /* Default type */
  621. X        H_YLabel
  622. X    };
  623. Xchar    *H_YTick[] = {
  624. X    "\t'YTick' controls the spacing of major axis ticks and the number\n",
  625. X    "\tof minor subdivisions. (ex. YTick=0.1,10 indicates major ticks at\n",
  626. X    "\tunits of 0.1 with 10 minor subdivisions.)\n",
  627. X    (char *)NULL
  628. X};
  629. XVALUE    V_YTick;
  630. XARGDEF    A_YTick = {
  631. X        &V_YTick,            /* variable    */
  632. X        "YTick",            /* ID        */
  633. X        "Automatic|interval",        /* options    */
  634. X        "string|interval",        /* format    */
  635. X        "Automatic",            /* default    */
  636. X        "string",            /* Default type */
  637. X        H_YTick
  638. X    };
  639. X    
  640. XARGDEF    *SymbolTable[] = {
  641. X        &A_AngularUnit,
  642. X        &A_AnnotationScale,
  643. X        &A_AspectRatio,
  644. X        &A_Boxed,
  645. X        &A_Domain,
  646. X        &A_Gridding,
  647. X        &A_Help,
  648. X        &A_LabelScale,
  649. X        &A_LineColor,
  650. X        &A_LineStyle,
  651. X        &A_Orientation,
  652. X        &A_Origin,
  653. X        &A_PlotColor,
  654. X        &A_PlotJoined,
  655. X        &A_PlotPoints,
  656. X        &A_PointScale,
  657. X        &A_PointSymbol,
  658. X        &A_PlotTitle,
  659. X        &A_PlotDevice,
  660. X        &A_PlotType,
  661. X        &A_PolarVariable,
  662. X        &A_Range,
  663. X        &A_SubPages,
  664. X        &A_SupplyAbscissa,
  665. X        &A_TitleScale,
  666. X        &A_UseInputFile,
  667. X        &A_UseOutputFile,
  668. X        &A_Verbose,
  669. X        &A_ViewPort,
  670. X        &A_XLabel,
  671. X        &A_YLabel,
  672. X        &A_XTick,
  673. X        &A_YTick,
  674. X        (ARGDEF *)NULL
  675. X    };
  676. X
  677. Xmain(argc, argv)
  678. Xint    argc;
  679. Xchar    **argv;
  680. X{
  681. X    register int    i;
  682. X    int    NTuples, TupleSize;
  683. X    FLOAT    **Data;
  684. X    FILE    *Fp;
  685. X    void    InterruptHandler();
  686. X#ifdef    ANSI_C
  687. X    FLOAT    **GetData(FILE *, int *, int *);
  688. X    void    ListPlot(FLOAT **,int ,int );
  689. X#else
  690. X    FLOAT    **GetData();
  691. X    void    ListPlot();
  692. X#endif
  693. X
  694. X
  695. X    get_args(argc, argv, SymbolTable, Usage, Function);
  696. X
  697. X    if (VtoBoolean(V_Verbose)) {
  698. X        fprintf(stderr, "Arg values:\n");
  699. X        for (i=0; SymbolTable[i]; i++) {
  700. X            fputc('\t' ,stderr);
  701. X            PrintArg(stderr, SymbolTable[i]);
  702. X        }
  703. X    }
  704. X
  705. X
  706. X    if (signal(SIGINT, SIG_IGN) != SIG_IGN)
  707. X        signal(SIGINT, InterruptHandler);
  708. X
  709. X
  710. X    if (strlen(V_UseInputFile.val_u.udt_string) > 0) {
  711. X        if ((Fp = fopen(V_UseInputFile.val_u.udt_string, "r")) == (FILE *)NULL) {
  712. X            perror(V_UseInputFile.val_u.udt_string);
  713. X            exit(errno);
  714. X        }
  715. X    } else {
  716. X        Fp = stdin;
  717. X    }
  718. X    if (strlen(V_UseOutputFile.val_u.udt_string) > 0) {
  719. X        if (!freopen(V_UseOutputFile.val_u.udt_string, "w", stdout)) {
  720. X            perror(V_UseOutputFile.val_u.udt_string);
  721. X            exit(errno);
  722. X        }
  723. X    }
  724. X    if ((Data = GetData(Fp, &NTuples, &TupleSize)) == (FLOAT **)NULL) {
  725. X        /* error */
  726. X        fprintf(stderr, "Unable to read data...\n");
  727. X        ErrorExit();
  728. X    }
  729. X
  730. X    ListPlot(Data, NTuples, TupleSize);
  731. X}
  732. X
  733. X
  734. Xvoid
  735. XInterruptHandler()
  736. X{
  737. X    ErrorExit();    /* will not return        */
  738. X    return;       /* To satisfy some compilers    */
  739. X}
  740. X
  741. X
  742. Xvoid
  743. XErrorExit()
  744. X{
  745. X    if (GraphicsInProgress)
  746. X        plend();
  747. X    exit(0);
  748. X}
  749. END_OF_FILE
  750. if test 19564 -ne `wc -c <'Csrc/ListPlot.c'`; then
  751.     echo shar: \"'Csrc/ListPlot.c'\" unpacked with wrong size!
  752. fi
  753. chmod +x 'Csrc/ListPlot.c'
  754. # end of 'Csrc/ListPlot.c'
  755. fi
  756. if test -f 'Csrc/get_args.c' -a "${1}" != "-c" ; then 
  757.   echo shar: Will not clobber existing file \"'Csrc/get_args.c'\"
  758. else
  759. echo shar: Extracting \"'Csrc/get_args.c'\" \(14827 characters\)
  760. sed "s/^X//" >'Csrc/get_args.c' <<'END_OF_FILE'
  761. X/*
  762. X * get_args.c
  763. X *
  764. X *    command line argument parser
  765. X */
  766. X#include <stdio.h>
  767. X#include <errno.h>
  768. Xextern int    errno;
  769. X#include <assert.h>
  770. X#include <ctype.h>
  771. X#include <string.h>
  772. X#include "datatypes.h"
  773. X
  774. X/*
  775. X#define    min(A,B)    A<B? A : B
  776. X#define    max(A,B)    A>B? A : B
  777. X*/
  778. X
  779. Xvoid
  780. Xget_args(argc, argv, Symbols, Usage, Function)
  781. Xint    argc;
  782. Xchar    **argv;
  783. XARGDEF    *Symbols[];
  784. Xchar    *Usage[], *Function[];
  785. X{
  786. X    register int    i;
  787. X    bool    helped;
  788. X    bool    Help(), ParseHelp();
  789. X
  790. X    /* set default values */
  791. X    SetDefaults(Symbols);
  792. X
  793. X    helped = FALSE;
  794. X    for (i=1; i<argc; i++)
  795. X        if (argv[i][0] == '?' || argv[i][0] == '-') {
  796. X            Help(Usage, Function, Symbols, "All");
  797. X            helped = TRUE;
  798. X        } else if (strncmp(argv[i], "Help",4)==0 || strncmp(argv[i],"help",4)==0) {
  799. X            ParseHelp(Usage, Function, Symbols, argv[i]);
  800. X            helped = TRUE;
  801. X        } else if (ParseArg(Symbols, argv[i])) {
  802. X            continue;
  803. X        } else {
  804. X            errno = EINVAL;
  805. X            perror(argv[i]);
  806. X            goto error_exit;
  807. X        }
  808. X    if (helped == TRUE)
  809. X        exit(0);
  810. X    else
  811. X        return;
  812. X
  813. Xerror_exit:
  814. X    PrintUsage(stderr, Usage, Function, Symbols);
  815. X    exit(errno);
  816. X}
  817. X
  818. X
  819. Xvoid
  820. XSetDefaults(Symbols)
  821. XARGDEF    *Symbols[];
  822. X{
  823. X    register int    i;
  824. X
  825. X    for (i=0; Symbols[i]; i++)
  826. X        if (SetValue(
  827. X            Symbols[i]->ad_value,
  828. X            Symbols[i]->ad_default,
  829. X            Symbols[i]->ad_defaultType
  830. X        ) != TRUE) {
  831. X            /* error */
  832. X            fprintf(stderr,"Internal error: (SetDefaults) Unable to set ");
  833. X            PrintArgDef(stderr,Symbols[i]);
  834. X            errno = EINVAL;
  835. X            exit(errno);
  836. X        }
  837. X    return;
  838. X}
  839. X
  840. X
  841. Xbool
  842. XSetValue(Val, ValStr, ValType)
  843. XVALUE    *Val;
  844. Xchar    *ValStr;
  845. Xchar    *ValType;
  846. X{
  847. X    register int    WidType;
  848. X
  849. X    WidType = strlen(ValType);
  850. X    if (strncmp(ValType, "string", WidType) == 0) {
  851. X        return(SetString(Val, ValStr));
  852. X    } else if (strncmp(ValType, "dbl", WidType) == 0) {
  853. X        return(SetDbl(Val, ValStr));
  854. X    } else if (strncmp(ValType, "float", WidType) == 0) {
  855. X        return(SetFloat(Val, ValStr));
  856. X    } else if (strncmp(ValType, "int", WidType) == 0) {
  857. X        return(SetInt(Val, ValStr));
  858. X    } else if (strncmp(ValType, "boolean", WidType) == 0) {
  859. X        return(SetBool(Val, ValStr));
  860. X    } else if (strncmp(ValType, "byte", WidType) == 0) {
  861. X        return(SetByte(Val, ValStr));
  862. X    } else if (strncmp(ValType, "interval", WidType) == 0) {
  863. X        return(SetInterval(Val, ValStr));
  864. X    } else if (strncmp(ValType, "set", min(WidType,3)) == 0) {
  865. X        return(SetSet(Val, ValStr, ValType, WidType));
  866. X    } else if (strncmp(ValType, "rect", WidType) == 0) {
  867. X        return(SetRect(Val, ValStr));
  868. X    } else {
  869. X        return(FALSE);
  870. X    }
  871. X}
  872. X
  873. X
  874. Xbool
  875. XSetString(Val, ValStr)
  876. XVALUE    *Val;
  877. Xchar    *ValStr;
  878. X{
  879. X    Val->val_type = string;
  880. X    Val->val_u.udt_string = StrDup(ValStr);
  881. X    return(TRUE);
  882. X}
  883. X
  884. X
  885. Xbool
  886. XSetDbl(Val, ValStr)
  887. XVALUE    *Val;
  888. Xchar    *ValStr;
  889. X{
  890. X    double    D;
  891. X
  892. X    if (sscanf(ValStr, "%lf", &D) == 1) {
  893. X        Val->val_type = dbl;
  894. X        Val->val_u.udt_dbl = D;
  895. X        return(TRUE);
  896. X    } else {
  897. X        return(FALSE);
  898. X    }
  899. X}
  900. X
  901. X
  902. Xbool
  903. XSetFloat(Val, ValStr)
  904. XVALUE    *Val;
  905. Xchar    *ValStr;
  906. X{
  907. X    float    F;
  908. X
  909. X    if (sscanf(ValStr, "%f", &F) == 1) {
  910. X        Val->val_type = flt;
  911. X        Val->val_u.udt_flt = F;
  912. X        return(TRUE);
  913. X    } else {
  914. X        return(FALSE);
  915. X    }
  916. X}
  917. X
  918. X
  919. Xbool
  920. XSetInt(Val, ValStr)
  921. XVALUE    *Val;
  922. Xchar    *ValStr;
  923. X{
  924. X    int    I;
  925. X
  926. X    if (sscanf(ValStr, "%d", &I) == 1) {
  927. X        Val->val_type = integer;
  928. X        Val->val_u.udt_int = I;
  929. X        return(TRUE);
  930. X    } else {
  931. X        return(FALSE);
  932. X    }
  933. X}
  934. X
  935. X
  936. Xbool
  937. XSetBool(Val, ValStr)
  938. XVALUE    *Val;
  939. Xchar    *ValStr;
  940. X{
  941. X    register int i, n;
  942. X    char    s[32];
  943. X
  944. X    n = min(strlen(ValStr),sizeof(s)-1);
  945. X    for (i=0; i<n; i++)
  946. X        s[i] = isupper(ValStr[i])? tolower(ValStr[i]) : ValStr[i];
  947. X    s[i] = (char)NULL;
  948. X    n = i - 1;
  949. X
  950. X    if (
  951. X        strncmp(s, "true", n) == 0 ||
  952. X        strncmp(s, "on", n) == 0 ||
  953. X        strncmp(s, "yes", n) == 0 ||
  954. X        strncmp(s, "1", n) == 0)
  955. X    {
  956. X        Val->val_type = boolean;
  957. X        Val->val_u.udt_bool = TRUE;
  958. X        return(TRUE);
  959. X    } else if (
  960. X        strncmp(s, "false", n) == 0 ||
  961. X        strncmp(s, "off", n) == 0 ||
  962. X        strncmp(s, "no", n) == 0 ||
  963. X        strncmp(s, "0", n) == 0)
  964. X    {
  965. X        Val->val_type = boolean;
  966. X        Val->val_u.udt_bool = FALSE;
  967. X        return(TRUE);
  968. X    } else {
  969. X        return(FALSE);
  970. X    }
  971. X}
  972. X
  973. X
  974. Xbool
  975. XSetByte(Val, ValStr)
  976. XVALUE    *Val;
  977. Xchar    *ValStr;
  978. X{
  979. X    char    C;
  980. X    Val->val_type = byte;
  981. X    if (sscanf(ValStr, "%c", &C) == 1) {
  982. X        Val->val_u.udt_byte = (char)C;
  983. X        return(TRUE);
  984. X    } else {
  985. X        return(FALSE);
  986. X    }
  987. X}
  988. X
  989. X
  990. Xbool
  991. XSetInterval(Val, ValStr)
  992. XVALUE    *Val;
  993. Xchar    *ValStr;
  994. X{
  995. X    double    lo, hi;
  996. X    Val->val_type = interval;
  997. X    if (sscanf(ValStr, "%lf,%lf", &lo,&hi) == 2) {
  998. X        Val->val_u.udt_interval.int_lo = lo;
  999. X        Val->val_u.udt_interval.int_hi = hi;
  1000. X        return(TRUE);
  1001. X    } else {
  1002. X        return(FALSE);
  1003. X    }
  1004. X}
  1005. X
  1006. X
  1007. Xbool
  1008. XSetSet(Val, ValStr, ValType, WidType)
  1009. XVALUE    *Val;
  1010. Xchar    *ValStr;
  1011. Xchar    *ValType;
  1012. Xint    WidType;
  1013. X{
  1014. X    int    i;
  1015. X    SET    *S;
  1016. X    char    *LeftBrace, *RightBrace;
  1017. X    char    *Start;
  1018. X    char    *sp;
  1019. X    bool    Escape;
  1020. X    int    WidStr;
  1021. X    char    s[128];
  1022. X    char    *SkipBlanks(char *);
  1023. X
  1024. X    Val->val_type = set;
  1025. X    S = &Val->val_u.udt_set;
  1026. X    S->list_n = 0;
  1027. X    S->list_head = (LATOM *)NULL;
  1028. X    S->list_tail = (LATOM *)NULL;
  1029. X
  1030. X    if ((LeftBrace = strchr(ValStr, '{')) == (char *)NULL) {
  1031. X        /*error*/
  1032. X        fprintf(stderr,"(SetSet) Invalid set specification:  \"%s\" (missing left brace).\n", ValStr);
  1033. X        exit(0);
  1034. X    }
  1035. X    Start = LeftBrace+1;
  1036. X    if ((RightBrace = strchr(ValStr, '}')) == (char *)NULL) {
  1037. X        /*error*/
  1038. X        fprintf(stderr,"(SetSet) Invalid set specification: \"%s\" (missing right brace).\n", ValStr);
  1039. X        exit(0);
  1040. X    }
  1041. X    WidStr = RightBrace - Start;
  1042. X
  1043. X    for (sp=Start; *sp && *sp != '}'; ) {
  1044. X/*         sp = SkipBlanks(sp); */
  1045. X        for ( Escape=FALSE,i=0; *sp && (Escape==TRUE || (Escape==FALSE && *sp != ',' && *sp != '}')); sp++) {
  1046. X            if (Escape == TRUE) {
  1047. X                s[i++] = *sp;
  1048. X                Escape = !Escape;
  1049. X            } else if (*sp == '\\' && Escape == FALSE) {
  1050. X                Escape = !Escape;
  1051. X            } else {
  1052. X                assert(*sp != '\\' && Escape == FALSE);
  1053. X                s[i++] = *sp;
  1054. X            }
  1055. X        }
  1056. X        s[i] = (char)NULL;
  1057. X        Append(S, (generic *)StrDup(s));
  1058. X        if (*sp == ',')
  1059. X            ++sp;
  1060. X    }
  1061. X
  1062. X    return(TRUE);
  1063. X}
  1064. X
  1065. X
  1066. Xbool
  1067. XSetRect(Val, ValStr)
  1068. XVALUE    *Val;
  1069. Xchar    *ValStr;
  1070. X{
  1071. X    register char    *sp;
  1072. X    register int    i;
  1073. X    FLOAT    *R;
  1074. X    char    *LeftBrace, *RightBrace;
  1075. X    char    *Start;
  1076. X    char    s[128];
  1077. X    char    *SkipBlanks(char *);
  1078. X    double    atof();
  1079. X
  1080. X    Val->val_type = rect;
  1081. X    R = Val->val_u.udt_rect.r_diag;
  1082. X
  1083. X    if ((LeftBrace = strchr(ValStr, '{')) == (char *)NULL) {
  1084. X        /*error*/
  1085. X        fprintf(stderr,"(SetRect) Invalid rect specification:  \"%s\" (missing left brace).\n", ValStr);
  1086. X        exit(0);
  1087. X    }
  1088. X    Start = LeftBrace+1;
  1089. X    if ((RightBrace = strchr(ValStr, '}')) == (char *)NULL) {
  1090. X        /*error*/
  1091. X        fprintf(stderr,"(SetRect) Invalid rect specification: \"%s\" (missing right brace).\n", ValStr);
  1092. X        exit(0);
  1093. X    }
  1094. X
  1095. X    for (sp=Start; *sp && *sp != '}'; ) {
  1096. X        sp = SkipBlanks(sp);
  1097. X        for ( i=0; *sp && *sp != ',' && *sp != '}'; sp++) {
  1098. X            s[i++] = *sp;
  1099. X        }
  1100. X        s[i] = (char)NULL;
  1101. X        *R++ = atof(s);
  1102. X        if (*sp == ',')
  1103. X            ++sp;
  1104. X    }
  1105. X
  1106. X    return(TRUE);
  1107. X}
  1108. X
  1109. X
  1110. Xchar *
  1111. XSkipBlanks(s)
  1112. Xregister char    *s;
  1113. X{
  1114. X    while(isspace(*s))
  1115. X        ++s;
  1116. X    return(s);
  1117. X}
  1118. X
  1119. X
  1120. Xvoid
  1121. XPrintUsage(Fp, Usage, Function, Symbols)
  1122. XFILE    *Fp;
  1123. Xchar    *Usage[];
  1124. Xchar    *Function[];
  1125. XARGDEF    *Symbols[];
  1126. X{
  1127. X    register int    i;
  1128. X
  1129. X    for (i=0; Usage[i]; i++)
  1130. X        fputs(Usage[i], Fp);
  1131. X    for (i=0; Function[i]; i++)
  1132. X        fputs(Function[i], Fp);
  1133. X    fprintf(Fp, "Options:\n");
  1134. X    for (i=0; Symbols[i]; i++) {
  1135. X        fputc('\t', Fp);
  1136. X        PrintArgDef(Fp, Symbols[i]);
  1137. X    }
  1138. X}
  1139. X
  1140. X
  1141. Xbool
  1142. XParseHelp(Usage, Function, Symbols, arg)
  1143. Xchar    *Usage;
  1144. Xchar    *Function;
  1145. XARGDEF    *Symbols[];
  1146. Xchar    *arg;
  1147. X{
  1148. X    bool    Help(); 
  1149. X    char    *EqualSign;
  1150. X
  1151. X    if (strncmp(arg, "Help", 4)==0 || strncmp(arg, "help", 4)==0) {
  1152. X        if ((EqualSign = strchr(arg,'=')) == (char *)NULL)
  1153. X            return(Help(Usage, Function, Symbols, "All"));
  1154. X        else
  1155. X            return(Help(Usage, Function, Symbols, EqualSign+1));
  1156. X    }
  1157. X    return(FALSE);
  1158. X}
  1159. X
  1160. X
  1161. Xbool
  1162. XHelp(Usage, Function, Symbols, arg)
  1163. Xchar    *Usage[];
  1164. Xchar    *Function[];
  1165. XARGDEF    *Symbols[];
  1166. Xchar    *arg;
  1167. X{
  1168. X    register int    i, j;
  1169. X    extern    VALUE    V_Verbose;
  1170. X
  1171. X    if (strcmp(arg, "All")==0 || strcmp(arg,"all")==0) {
  1172. X        if (VtoBoolean(V_Verbose)) {
  1173. X            for (i=0; Usage[i]; i++)
  1174. X                fputs(Usage[i], stdout);
  1175. X            for (i=0; Function[i]; i++)
  1176. X                fputs(Function[i], stdout);
  1177. X            fprintf(stdout, "Options:\n");
  1178. X            for (i=0; Symbols[i]; i++) {
  1179. X                fputc('\t', stdout);
  1180. X                PrintArgDef(stdout, Symbols[i]);
  1181. X                if ( Symbols[i]->ad_helptext != (char **)NULL) {
  1182. X                    for (j=0; Symbols[i]->ad_helptext[j]; j++)
  1183. X                        fputs(Symbols[i]->ad_helptext[j], stdout);
  1184. X                }
  1185. X                fputc('\n', stdout);
  1186. X            }
  1187. X        } else {
  1188. X            fputs(Usage[0], stdout);
  1189. X            fputs(Function[0], stdout);
  1190. X            fprintf(stderr, "Options:\n");
  1191. X            for (i=0; Symbols[i]; i++) {
  1192. X                fputc('\t', stdout);
  1193. X                PrintArgDef(stdout, Symbols[i]);
  1194. X            }
  1195. X        }
  1196. X        return(TRUE);
  1197. X    } else {
  1198. X        /* find entry in symbol table    */
  1199. X        for (i=0; Symbols[i]; i++) {
  1200. X            if (strcmp(arg,Symbols[i]->ad_id) == 0) {
  1201. X                /* found */
  1202. X                fputc('\t', stdout);
  1203. X                PrintArgDef(stdout, Symbols[i]);
  1204. X                if (VtoBoolean(V_Verbose) && Symbols[i]->ad_helptext != (char **)NULL) {
  1205. X                    for (j=0; Symbols[i]->ad_helptext[j]; j++)
  1206. X                        fputs(Symbols[i]->ad_helptext[j], stdout);
  1207. X                    fputc('\n', stdout);
  1208. X                }
  1209. X                return(TRUE);
  1210. X            }
  1211. X        }
  1212. X    }
  1213. X    return(FALSE);
  1214. X}
  1215. X
  1216. X
  1217. X
  1218. X
  1219. Xbool
  1220. XParseArg(Symbols, arg)
  1221. XARGDEF    *Symbols[];
  1222. Xchar    *arg;
  1223. X{
  1224. X    register int    i;
  1225. X    char        *EqualSign;
  1226. X    char        *ValueStr;
  1227. X    int        wid;
  1228. X
  1229. X    if ((EqualSign = strchr(arg,'=')) == (char *)NULL) {
  1230. X        ValueStr = arg;
  1231. X        wid = strlen(ValueStr);
  1232. X    } else {
  1233. X        ValueStr = EqualSign + 1;
  1234. X        wid = EqualSign - arg;
  1235. X    }
  1236. X
  1237. X    /* find entry in symbol table    */
  1238. X    for (i=0; Symbols[i]; i++) {
  1239. X        if (strncmp(arg,Symbols[i]->ad_id, wid) == 0) {
  1240. X            /* found */
  1241. X            return(ParseEntry(Symbols[i], ValueStr));
  1242. X        }
  1243. X    }
  1244. X    
  1245. X    return(FALSE);
  1246. X}
  1247. X
  1248. X
  1249. Xbool
  1250. XParseEntry(Entry, arg)
  1251. XARGDEF    *Entry;
  1252. Xchar    *arg;
  1253. X{
  1254. X    char    *StartOpt, *StartType;
  1255. X    char    *BarOpt;
  1256. X    char    *BarType;
  1257. X    int    WidOpt, WidType;
  1258. X
  1259. X    StartOpt = Entry->ad_options;
  1260. X    StartType = Entry->ad_opttype;
  1261. X    do {
  1262. X        if ((BarOpt = strchr(StartOpt,'|')) == (char *)NULL) {
  1263. X            WidOpt = strlen(StartOpt);
  1264. X        } else {
  1265. X            WidOpt = BarOpt - StartOpt;
  1266. X        }
  1267. X        if ((BarType = strchr(StartType,'|')) == (char *)NULL) {
  1268. X            WidType = strlen(StartType);
  1269. X        } else {
  1270. X            WidType = BarType - StartType;
  1271. X        }
  1272. X
  1273. X        if (strncmp(StartType, "string", WidType) == 0) {
  1274. X            if (ParseString(Entry, StartOpt, WidOpt, arg) == TRUE)
  1275. X                return(TRUE);
  1276. X            else {
  1277. X                StartOpt = ++BarOpt;
  1278. X                StartType = ++BarType;
  1279. X                continue;
  1280. X            }
  1281. X        } else  if (strncmp(StartType, "dbl", WidType) == 0) {
  1282. X            if (ParseDbl(Entry, arg) == TRUE)
  1283. X                return(TRUE);
  1284. X            else {
  1285. X                StartOpt = ++BarOpt;
  1286. X                StartType = ++BarType;
  1287. X                continue;
  1288. X            }
  1289. X        } else if (strncmp(StartType, "float", WidType) == 0) {
  1290. X            if (ParseFloat(Entry, arg) == TRUE)
  1291. X                return(TRUE);
  1292. X            else {
  1293. X                StartOpt = ++BarOpt;
  1294. X                StartType = ++BarType;
  1295. X                continue;
  1296. X            }
  1297. X        } else if (strncmp(StartType, "int", WidType) == 0) {
  1298. X            if (ParseInt(Entry, arg) == TRUE)
  1299. X                return(TRUE);
  1300. X            else {
  1301. X                StartOpt = ++BarOpt;
  1302. X                StartType = ++BarType;
  1303. X                continue;
  1304. X            }
  1305. X        } else if (strncmp(StartType, "boolean", WidType) == 0) {
  1306. X            if (ParseBool(Entry, arg) == TRUE)
  1307. X                return(TRUE);
  1308. X            else {
  1309. X                StartOpt = ++BarOpt;
  1310. X                StartType = ++BarType;
  1311. X                continue;
  1312. X            }
  1313. X        } else if (strncmp(StartType, "byte", WidType) == 0) {
  1314. X            if (ParseByte(Entry, arg) == TRUE)
  1315. X                return(TRUE);
  1316. X            else {
  1317. X                StartOpt = ++BarOpt;
  1318. X                StartType = ++BarType;
  1319. X                continue;
  1320. X            }
  1321. X        } else if (strncmp(StartType, "interval", WidType) == 0) {
  1322. X            if (ParseInterval(Entry, arg) == TRUE)
  1323. X                return(TRUE);
  1324. X            else {
  1325. X                StartOpt = ++BarOpt;
  1326. X                StartType = ++BarType;
  1327. X                continue;
  1328. X            }
  1329. X        } else if (strncmp(StartType, "set", min(WidType,3)) == 0) {
  1330. X            if (ParseSet(Entry, arg, StartType,WidType) == TRUE) {
  1331. X                return(TRUE);
  1332. X            } else {
  1333. X                StartOpt = ++BarOpt;
  1334. X                StartType = ++BarType;
  1335. X                continue;
  1336. X            }
  1337. X        } else if (strncmp(StartType, "rect", WidType) == 0) {
  1338. X            if (ParseRect(Entry, arg) == TRUE) {
  1339. X                return(TRUE);
  1340. X            } else {
  1341. X                StartOpt = ++BarOpt;
  1342. X                StartType = ++BarType;
  1343. X                continue;
  1344. X            }
  1345. X        } else {
  1346. X            fprintf(stderr, "Internal Error: invalid option type string: \"%s\"\n", StartType);
  1347. X            PrintArgDef(stderr,Entry);
  1348. X            errno = EINVAL;
  1349. X            exit(errno);
  1350. X        }
  1351. X    } while(StartOpt != (char)NULL && StartType != (char)NULL);
  1352. X    return(TRUE);
  1353. X}
  1354. X
  1355. X
  1356. Xbool
  1357. XParseString(Entry, Option, n, arg)
  1358. XARGDEF    *Entry;
  1359. Xchar    *Option;
  1360. Xint    n;
  1361. Xchar    *arg;
  1362. X{
  1363. X    if (*Option == '*') {
  1364. X         /* Match any string    */
  1365. X        Entry->ad_value->val_type = string;
  1366. X        Entry->ad_value->val_u.udt_string = StrDup(arg);
  1367. X        return(TRUE);
  1368. X    } else if (arg!=(char *)NULL && strncmp(arg,Option,strlen(arg)) == 0) {
  1369. X        /* Matches option    */
  1370. X        Entry->ad_value->val_type = string;
  1371. X        Entry->ad_value->val_u.udt_string = StrDup(arg);
  1372. X        return(TRUE);
  1373. X    } else {
  1374. X        return(FALSE);
  1375. X    }
  1376. X}
  1377. X
  1378. Xchar    *
  1379. XStrDup(Str)
  1380. Xchar    *Str;
  1381. X{
  1382. X    register int    n;
  1383. X    register char    *Dup;
  1384. X
  1385. X    if (Str == (char *)NULL)
  1386. X        return((char *)NULL);
  1387. X
  1388. X    n = strlen(Str);
  1389. X    if ((Dup = malloc(n+1)) == (char *)NULL) {
  1390. X        perror("(StrDup) ");
  1391. X        assert(Dup != (char *)NULL);
  1392. X        exit(errno);
  1393. X    }
  1394. X    memcpy(Dup, Str, n+1);
  1395. X    return(Dup);
  1396. X}
  1397. X
  1398. X
  1399. Xbool
  1400. XParseDbl(Entry, arg)
  1401. XARGDEF    *Entry;
  1402. Xchar    *arg;
  1403. X{
  1404. X    return(SetDbl(Entry->ad_value, arg));
  1405. X}
  1406. X
  1407. Xbool
  1408. XParseFloat(Entry, arg)
  1409. XARGDEF    *Entry;
  1410. Xchar    *arg;
  1411. X{
  1412. X    return(SetFloat(Entry->ad_value, arg));
  1413. X}
  1414. X
  1415. Xbool
  1416. XParseInt(Entry, arg)
  1417. XARGDEF    *Entry;
  1418. Xchar    *arg;
  1419. X{
  1420. X    return(SetInt(Entry->ad_value, arg));
  1421. X}
  1422. X
  1423. Xbool
  1424. XParseBool(Entry, arg)
  1425. XARGDEF    *Entry;
  1426. Xchar    *arg;
  1427. X{
  1428. X    return(SetBool(Entry->ad_value, arg));
  1429. X}
  1430. X
  1431. Xbool
  1432. XParseByte(Entry, arg)
  1433. XARGDEF    *Entry;
  1434. Xchar    *arg;
  1435. X{
  1436. X    return(SetByte(Entry->ad_value, arg));
  1437. X}
  1438. X
  1439. Xbool
  1440. XParseInterval(Entry, arg)
  1441. XARGDEF    *Entry;
  1442. Xchar    *arg;
  1443. X{
  1444. X    return(SetInterval(Entry->ad_value, arg));
  1445. X}
  1446. X
  1447. Xbool
  1448. XParseSet(Entry, arg, Type, WidType)
  1449. XARGDEF    *Entry;
  1450. Xchar    *arg;
  1451. Xchar    *Type;
  1452. Xint    WidType;
  1453. X{
  1454. X    return(SetSet(Entry->ad_value, arg, Type, WidType));
  1455. X}
  1456. X
  1457. Xbool
  1458. XParseRect(Entry, arg)
  1459. XARGDEF    *Entry;
  1460. Xchar    *arg;
  1461. X{
  1462. X    return(SetRect(Entry->ad_value, arg));
  1463. X}
  1464. X
  1465. X
  1466. Xvoid
  1467. XPrintArgDef(Fp, Def)
  1468. XFILE    *Fp;
  1469. XARGDEF    *Def;
  1470. X{
  1471. X    fprintf(Fp, "%s=", Def->ad_id);
  1472. X    fprintf(Fp, "[%s]", Def->ad_options);
  1473. X    fprintf(Fp, " default: %s\n", Def->ad_default);
  1474. X    fflush(Fp);
  1475. X}
  1476. X
  1477. X
  1478. Xvoid
  1479. XPrintArg(Fp, Def)
  1480. XFILE    *Fp;
  1481. XARGDEF    *Def;
  1482. X{
  1483. X    LATOM    *A;
  1484. X
  1485. X    switch(Def->ad_value->val_type) {
  1486. X    default:
  1487. X        fprintf(Fp,"%s=<Invalid datatype>!\n", Def->ad_id);
  1488. X        break;
  1489. X    case boolean:
  1490. X        fprintf(Fp,"%s=%s\n",
  1491. X            Def->ad_id,
  1492. X            Def->ad_value->val_u.udt_bool? "TRUE":"FALSE");
  1493. X        break;
  1494. X    case integer:
  1495. X        fprintf(Fp,"%s=%d\n",Def->ad_id,Def->ad_value->val_u.udt_int);
  1496. X        break;
  1497. X    case dbl:
  1498. X        fprintf(Fp,"%s=%lg\n",Def->ad_id,Def->ad_value->val_u.udt_dbl);
  1499. X        break;
  1500. X    case flt:
  1501. X        fprintf(Fp,"%s=%g\n",Def->ad_id,Def->ad_value->val_u.udt_flt);
  1502. X        break;
  1503. X    case byte:
  1504. X        fprintf(Fp,"%s=%c\n",Def->ad_id,Def->ad_value->val_u.udt_byte);
  1505. X        break;
  1506. X    case string:
  1507. X        fprintf(Fp,"%s=\"%s\"\n",Def->ad_id,Def->ad_value->val_u.udt_string);
  1508. X        break;
  1509. X    case interval:
  1510. X        fprintf(Fp,"%s=%g,%g\n",Def->ad_id,Def->ad_value->val_u.udt_interval);
  1511. X        break;
  1512. X    case set:
  1513. X        fprintf(Fp,"%s={\n",Def->ad_id);
  1514. X        for (A=Def->ad_value->val_u.udt_set.list_head; A; A=A->la_next)
  1515. X            if (A->la_next)
  1516. X                fprintf(Fp,"\t\t<%s>,\n",(char *)A->la_p);
  1517. X            else
  1518. X                fprintf(Fp,"\t\t<%s>\n",(char *)A->la_p);
  1519. X        fprintf(Fp, "\t}\n");
  1520. X        break;
  1521. X    case rect:
  1522. X        fprintf(
  1523. X            Fp,
  1524. X            "%s={%g,%g, %g,%g}\n",
  1525. X            Def->ad_id,
  1526. X            Def->ad_value->val_u.udt_rect.r_diag[0],
  1527. X            Def->ad_value->val_u.udt_rect.r_diag[1],
  1528. X            Def->ad_value->val_u.udt_rect.r_diag[2],
  1529. X            Def->ad_value->val_u.udt_rect.r_diag[3]
  1530. X        );
  1531. X        break;
  1532. X    }
  1533. X}
  1534. END_OF_FILE
  1535. if test 14827 -ne `wc -c <'Csrc/get_args.c'`; then
  1536.     echo shar: \"'Csrc/get_args.c'\" unpacked with wrong size!
  1537. fi
  1538. chmod +x 'Csrc/get_args.c'
  1539. # end of 'Csrc/get_args.c'
  1540. fi
  1541. if test -f 'docs/ListPlot.uu' -a "${1}" != "-c" ; then 
  1542.   echo shar: Will not clobber existing file \"'docs/ListPlot.uu'\"
  1543. else
  1544. echo shar: Extracting \"'docs/ListPlot.uu'\" \(19126 characters\)
  1545. sed "s/^X//" >'docs/ListPlot.uu' <<'END_OF_FILE'
  1546. Xbegin 600 ListPlot.man
  1547. XM"B`@("`@3&ES=%!L;W0H,2D@("`@("`@("`@("`@("`@("!!34E'02!-86YUW
  1548. XM86P@("`@("`@("`@("`@("`@("!,:7-T4&QO="@Q*0H*"@H@("`@()LQ;4Y!:
  1549. XM344@"B`@("`@("`@("";,&U,:7-T4&QO="`M(&$@=F%N:6QL82!P;&]T=&ENN
  1550. XM9R!F:6QT97(@"@H@("`@()LQ;5-93D]04TE3(`H@("`@("`@("`@3&ES=%!LD
  1551. XM;W0@FS!M6R!O<'1I;VYS(%T@"@H@("`@()LQ;41%4T-225!424].(`H@("`@Z
  1552. XM("`@("`@FS!MFS-M3&ES=%!L;W0@()LP;6$@('-I;7!L92`@,D0@('!L;W1TZ
  1553. XM:6YG(&9I;'1E<B!B87-E9"!O;B!T:&4@FS-M4$Q03$]4"B`@("`@("`@("";\
  1554. XM,&UP;&]T=&EN9R!L:6)R87)Y+B`@"@H@("`@("`@("`@271S('!R:6YC:7!L6
  1555. XM92!A9'9A;G1A9V4@:7,@=&AA="!I="`@<W5P<&]R=',@(&$@('9A<FEE='D@/
  1556. XM(&]F"B`@("`@("`@("!G<F%P:&EC<R!D979I8V5S+B`@"@H@("`@("`@("`@5
  1557. XMFS-M3&ES=%!L;W0@()LP;7)E861S(&9R;VT@<W1D:6X@86YD('=R:71E<R!TX
  1558. XM;R!S=&1O=70@=6YL97-S(&EN<'5T"B`@("`@("`@("!A;F0O;W(@;W5T<'5T:
  1559. XM(&9I;&5S(&%R92!S<&5C:69I960@;VX@=&AE(&-O;6UA;F0@;&EN92X@("!4>
  1560. XM:&4*("`@("`@("`@('!R;V=R86T@86-C97!T<R`@82!F:6QE(&]F(&XM='5P\
  1561. XM;&5S+B`@16%C:"!T=7!L92!C;VYS:7-T<R!O9@H@("`@("`@("`@82!S97%U!
  1562. XM96YC92!O9B`@<W!A8V4M<V5P87)A=&5D("!N=6UB97)S("!T97)M:6YA=&5DK
  1563. XM("!W:71H("!A"B`@("`@("`@("!N97=L:6YE+B`@(%1H92`@9FER<W0@96QE&
  1564. XM;65N="!O9B!E86-H('1U<&QE(&ES(&%S<W5M960@=&\@8F4*("`@("`@("`@&
  1565. XM('1H92!I;F1E<&5N9&5N="!V87)I86)L92X@($5A8V@@<F5M86EN:6YG(&5L?
  1566. XM96UE;G0@:7,@<&QO='1E9`H@("`@("`@("`@86=A:6YS="!T:&4@9FER<W0@K
  1567. XM=&\@<')O9'5C92!N+3$@8W5R=F5S+B`@"@H@("`@("`@("`@FS-M3&ES=%!LN
  1568. XM;W0@FS!M=&%K97,@82!N=6UB97(@;V8@8V]M;6%N9"!L:6YE(&%R9W5M96YT\
  1569. XM<R`@=&AA="`@;6%Y"B`@("`@("`@("!B92!U<V5D("!T;R`@8V]N=')O;"`@Q
  1570. XM=&AE("!A<'!E87)A;F-E(&]F('1H92!P;&]T<RX@($-O;6UA;F0*("`@("`@P
  1571. XM("`@(&QI;F4@87)G=6UE;G1S(&%R92!S<&5C:69I960@:6X@=&AE(&9O<FT@.
  1572. XM"B`@("`@("`@("`@("`@("`@("`@FS-M=F%R:6%B;&4]=F%L=64@"@H@("`@9
  1573. XM("`@("`@FS!M1F]R(&$@;&ES="!O9B!T:&4@87)G=6UE;G1S(&5N=&5R.B`*J
  1574. XM"B`@("`@("`@("`@("`@("`@("`@3&ES=%!L;W0@2&5L<#U!;&PN("`*"B`@&
  1575. XM("`@FS%M5D%224%"3$53(%194$53(`H@("`@("`@("`@0F]O;&5A;J";,&V@)
  1576. XMH'9A;'5E<R!A8V-E<'0@=F%L=65S('-U8V@@87,@FS%M=')U99LP;2P@FS%M-
  1577. XM9F%L<V6;,&TL()LQ;7EE<YLP;2P@FS%M;F^;,&TL"B`@("`@("`@("`@("`@A
  1578. XM("`@("`@FS%M;VZ;,&TL()LQ;6]F9ILP;2P@FS%M,)LP;2P@86YD()LQ;3$@<
  1579. XMFS!M*&5X+B!0;&]T0V]L;W(]>65S*2X@(`H*("`@("`@("`@()LQ;5-T<FENK
  1580. XM9Z";,&V@H*!V86QU97,@97AP96-T('1H92!S=')I;F=S('1O(&5N=&5R960@-
  1581. XM87,@(&EN9&EC871E9`H@("`@("`@("`@("`@("`@("`@(&%N9"!I<R!C87-EN
  1582. XM('-E;G-I=&EV92`H97@N($1O;6%I;CU!;&PI+B`@"@H@("`@("`@("`@FS%M_
  1583. XM1&)LH)LP;:"@H*"@H'9A;'5E<R!E>'!E8W0@<F5A;"!N=6UB97)S("AE>"X@V
  1584. XM07-P96-T4F%T:6\],2XP*2X@(`H*("`@("`@("`@()LQ;4EN=&5R=F%LH)LP_
  1585. XM;:!V86QU97,@97AP96-T(&$@<&%I<B!O9B!C;VUM82!S97!A<F%T960@<F5AF
  1586. XM;',@*&5X+@H@("`@("`@("`@("`@("`@("`@(%)A;F=E/2TQ+C`L,RXP*2X@6
  1587. XM(`H*("`@("`@("`@()LQ;5-E=*";,&V@H*"@H*!V86QU97,@(&5X<&5C="`@*
  1588. XM82!L:7-T(&]F(&-O;6UA('-E<&%R871E9"!E;&5M96YT<PH@("`@("`@("`@_
  1589. XM("`@("`@("`@(&5N8VQO<V5D("`@(&EN("`@(&-U<FQY("`@(&)R86-E<R`@#
  1590. XM("`H>WTI+B`@("`H97@N"B`@("`@("`@("`@("`@("`@("`@3&EN95-T>6QE-
  1591. XM/7M-4RQ-35,L35-M;5-]*2`*"B`@("`@("`@("";,6U296-TH)LP;:"@H*"@#
  1592. XM=F%L=65S("!E>'!E8W0@(&$@(&QI<W0@;V8@8V]M;6$@<V5P87)A=&5D(&YUT
  1593. XM;6)E<G,*("`@("`@("`@("`@("`@("`@("!R97!R97-E;G1I;F<@82!D:6%GO
  1594. XM;VYA;"!F<F]M('1H92!L;W=E<BUL969T(&-O<FYE<@H@("`@("`@("`@("`@3
  1595. XM("`@("`@('1O('1H92!U<'!E<BUR:6=H="!C;W)N97(@*&5X+B`@5FEE=U!O1
  1596. XM<G0]>S`N,2PP+C,L"B`@("`@("`@("`@("`@("`@("`@,"XY+#`N-GTI+B`@+
  1597. XM"@H*("`@("`@("`@(%1H92`@=&ET;&4@(&%N9"`@;&%B96P@=F%R:6%B;&5SM
  1598. XM(&%C8V5P="!S=')I;F=S('1H870@:6YC;'5D90H@("`@("`@("`@=&AE(&9O/
  1599. XM;&QO=VEN9R!C;VYT<F]L('-E<75E;F-E<SH@"@H@("`@("`@("`@("`@("`@W
  1600. XM("`@(".;,6UUFS!M.B!M;W9E('5P('1O('-U<&5R<V-R:7!T("AE;F1E9"!WE
  1601. XM:71H(".;,6UD()LP;2D@"B`@("`@("`@("`@("`@("`@("`@(YLQ;62;,&TZ"
  1602. XM(&UO=F4@9&]W;B!T;R!S=6)S8W)I<'0@*&5N9&5D('=I=&@@(YLQ;74@FS!M>
  1603. XM*2`*"@H@("`@(#4O,34O.3`@("`@("`@("`@("`@("`@("`@("`@("`@("TQ'
  1604. XM+2`@("`@("`@("`@("`@("`@("!$=6ME(%5N:79E<G-I='D*"@H@("`@($QIK
  1605. XM<W10;&]T*#$I("`@("`@("`@("`@("`@("`@04U)1T$@36%N=6%L("`@("`@E
  1606. XM("`@("`@("`@("`@3&ES=%!L;W0H,2D*"@H@("`@("`@("`@("`@("`@("`@[
  1607. XM(".;,6UBFS!M.B!B86-K<W!A8V4@=&\@86QL;W<@;W9E<G!R:6YT:6YG(`H@@
  1608. XM("`@("`@("`@("`@("`@("`@(",C.B!T:&4@;G5M8F5R('-Y;6)O;"`*("`@J
  1609. XM("`@("`@("`@("`@("`@("`C*SH@=&]G9VQE(&]V97)L:6YE(&UO9&4@"B`@]
  1610. XM("`@("`@("`@("`@("`@("`@(RTZ('1O9V=L92!U;F1E<FQI;F4@;6]D92`*!
  1611. XM("`@("`@("`@("`@("`@("`@("`CFS%M9WB;,&TZ($=R965K(&QE='1E<B!CN
  1612. XM;W)R97-P;VYD:6YG('1O(%)O;6%N(&QE='1E<B!X(`H*("`@("";,6U/4%1)+
  1613. XM3TY3(`H@("`@("`@("`@FS!M5&AE(&-U<G)E;G1L>2!A=F%I;&%B;&4@87)G6
  1614. XM=6UE;G1S(&%R92!I;F1I8V%T960@8F5L;W<N("";,6U";VQD"B`@("`@("`@D
  1615. XM("";,&UF86-E(&%R9W5M96YT<R!I;F1I8V%T92!T:&%T('1H97D@<VAO=6QDX
  1616. XM(&)E(&5N=&5R960@(&5X86-T;'D*("`@("`@("`@(&%S('-H;W=N+B`@($%N2
  1617. XM("<J)R!I;F1I8V%T97,@=&AA="!A;B!A<F)I=')A<GD@<W1R:6YG(&UA>2!B\
  1618. XM90H@("`@("`@("`@9VEV96XN("!!('-T<FEN9R!W:71H(&5M8F5D9&5D('-P7
  1619. XM86-E<R!M=7-T(&)E('%U;W1E9"X@(`H*("`@("`@("`@()LQ;4%N9W5L87)5X
  1620. XM;FETFS!M/5L@FS%M9&5G<F5E<R";,&U\()LQ;7)A9&EA;G,@FS!M72`*("`@A
  1621. XM("`@("`@("`@("`@("`@("";,VU!;F=U;&%R56YI="";,&US<&5C:69I97,@X
  1622. XM=&AE(&%N9W5L87(@=6YI="!O9B`@;65A<W5R90H@("`@("`@("`@("`@("`@<
  1623. XM("`@('5S960@9F]R("!P;VQA<B`@<&QO=',N("!&;W(@86YG;&5S(&EN(')A!
  1624. XM9&EA;G,@=7-E"B`@("`@("`@("`@("`@("`@("`@FS%M06YG=6QA<E5N:72;$
  1625. XM,&T]FS%M<F%D:6%N<YLP;2X@"@H@("`@("`@("`@FS%M06YN;W1A=&EO;E-C9
  1626. XM86QEFS!M/5L@FS-M9&)L()LP;5T@"B`@("`@("`@("`@("`@("`@("`@FS-MI
  1627. XM06YN;W1A=&EO;E-C86QE("`@FS!M8V]N=')O;',@("!T:&4@("!S:7IE("`@K
  1628. XM;V8@("!T:&4*("`@("`@("`@("`@("`@("`@("!C:&%R86-T97)S('5S960@1
  1629. XM=&\@86YN;W1A=&4@=&AE(&%X97,N("`*"B`@("`@("`@("";,6U!<W!E8W12\
  1630. XM871I;YLP;3U;()LS;61B;"";,&U\()LQ;4%U=&]M871I8R";,&U=(`H@("`@]
  1631. XM("`@("`@("`@("`@("`@()LS;4%S<&5C=%)A=&EO("";,&UC;VYT<F]L<R`@&
  1632. XM=&AE(')E;&%T:79E(&QE;F=T:',@;V8@=&AE"B`@("`@("`@("`@("`@("`@2
  1633. XM("`@=F5R=&EC86P@=&\@:&]R:7IO;G1A;"!A>&5S+B`@268@('-E="`@=&AIF
  1634. XM<R`@=F%L=64*("`@("`@("`@("`@("`@("`@("!O=F5R<FED97,@=&AE('9A%
  1635. XM;'5E(&]F()LS;59I97=0;W)T+B`*"B`@("`@("`@("";,&V;,6U";WAE9)LPF
  1636. XM;3U;()LS;6)O;VQE86X@FS!M?"`J(%T@"B`@("`@("`@("`@("`@("`@("`@%
  1637. XMFS-M0F]X960@FS!M861D<R`@87AE<R`@=&\@('1H92`@961G97,@(&]F('1H/
  1638. XM92!P;&]T+B`@268*("`@("`@("`@("`@("`@("`@("";,VU";WAE9"";,&UI9
  1639. XM<R!G:79E;B`@82`@8F]O;&5A;B`@=F%L=64@('1H96X@(&%X97,@(&%R90H@,
  1640. XM("`@("`@("`@("`@("`@("`@('!L86-E9"!O;B`@86QL("!O9B!T:&4@961G%
  1641. XM97,N("!)9B";,VU";WAE9"";,&UI<R!G:79E;B!A"B`@("`@("`@("`@("`@Z
  1642. XM("`@("`@<W1R:6YG(&-O;G-I<W1I;F<@;V8@;VYE(&]R(&UO<F4@;V8@()LSF
  1643. XM;70L("!B+"`@<BP@(&P*("`@("`@("`@("`@("`@("`@("";,&UT:&5N(&%X/
  1644. XM97,@87)E(&%D9&5D('1O('1O<"P@8F]T=&]M+"!R:6=H="!A;F0@;&5F=`H@+
  1645. XM("`@("`@("`@("`@("`@("`@(&5D9V5S(')E<W!E8W1I=F5L>2X@(`H*("`@)
  1646. XM("`@("`@()LQ;41O;6%I;ILP;3U;()LS;6EN=&5R=F%L()LP;7P@FS%M06QL'
  1647. XM()LP;7P@FS%M075T;VUA=&EC()LP;5T@"B`@("`@("`@("`@("`@("`@("`@S
  1648. XMFS-M1&]M86EN("";,&UM87D@8F4@=7-E9"!T;R!S<&5C:69Y('1H92!B;W5N5
  1649. XM9',@;VX@=&AE(%@*("`@("`@("`@("`@("`@("`@("!A>&ES+B`@5VAE;B!S_
  1650. XM970@=&\@FS%M06QLFS!M+"!A;&P@('!O:6YT<R`@87)E("!P;&]T=&5D+@H@T
  1651. XM("`@("`@("`@("`@("`@("`@(%=H96X@('-E="!T;R";,6U!=71O;6%T:6.;<
  1652. XM,&TL(&]U=&QY:6YG('!O:6YT<R!M87D@;F]T(&)E"B`@("`@("`@("`@("`@J
  1653. XM("`@("`@<&QO='1E9"X@(`H*("`@("`@("`@()LQ;4=R:61D:6YGFS!M/5L@/
  1654. XMFS-M8F]O;&5A;B";,&U=(`H@("`@("`@("`@("`@("`@("`@()LS;4=R:61D?
  1655. XM:6YG()LP;7!U=',@82!G<FED(&]N('1H92!P;&]T+B`@"@H@("`@("`@("`@H
  1656. XMFS%M2&5L<)LP;3U;()LQ;4%L;"";,&U\()LQ;6%L;"";,&U\("H@72`*("`@/
  1657. XM("`@("`@("`@("`@("`@("";,VU(96QP("";,&UP<F]V:61E<R`@<V]M92`@\
  1658. XM9&5S8W)I<'1I=F4@('1E>'0@(&9O<B`@('1H90H@("`@("`@("`@("`@("`@9
  1659. XM("`@('5S97(M<V5T=&%B;&4@<&QO='1I;F<@=F%R:6%B;&5S+B`@268@=&AEH
  1660. XM('9A<FEA8FQE"B`@("`@("`@("`@("`@("`@("`@FS-M5F5R8F]S92`@FS!MY
  1661. XM:7,@('-E="`@=&AE;B`@86X@97AT96YD960@9&5S8W)I<'1I;VX@:7,*("`@!
  1662. XM("`@("`@("`@("`@("`@("!P<F]V:61E9"X@(%1O('-E="!V97)B;W-E(&5NC
  1663. XM=&5R(`H*("`@("`@("`@("`@("`@("`@("!,:7-T4&QO="!697)B;W-E/7EE+
  1664. XM<R!(96QP/5L@FS-M=F%R:6%B;&4@FS!M?"";,6U!;&P@FS!M72X@(`H*("`@R
  1665. XM("`@("`@()LQ;4QA8F5L4V-A;&6;,&T]6R";,VUD8FP@FS!M72`*("`@("`@=
  1666. XM("`@("`@("`@("`@("";,VU,86)E;%-C86QE()LP;7-P96-I9FEE<R`@=&AE7
  1667. XM("!R96QA=&EV92`@<VEZ92`@;V8@('1H90H@("`@("`@("`@("`@("`@("`@7
  1668. XM('9E<G1I8V%L(&%N9"`@:&]R:7IO;G1A;"!A>&ES(&QA8F5L<RX@(%1H92!TB
  1669. XM>7!I8V%L"B`@("`@("`@("`@("`@("`@("`@<F%N9V4@:7,@6S`N-2`M(#(NP
  1670. XM,%TN("`*"B`@("`@("`@("";,6U,:6YE0V]L;W*;,&T]6R";,VUS970@FS!M>
  1671. XM72`*("`@("`@("`@("`@("`@("`@("";,VU,:6YE0V]L;W(@FS!M;6%Y(&)E/
  1672. XM('5S960@=&\@<W!E8VEF>2!A("!L:7-T("!O9B`@;&EN90H*"B`@("`@-2\QT
  1673. XM-2\Y,"`@("`@("`@("`@("`@("`@("`@("`@("`@+3(M("`@("`@("`@("`@9
  1674. XM("`@("`@($1U:V4@56YI=F5R<VET>0H*"B`@("`@3&ES=%!L;W0H,2D@("`@&
  1675. XM("`@("`@("`@("`@("!!34E'02!-86YU86P@("`@("`@("`@("`@("`@("!,I
  1676. XM:7-T4&QO="@Q*0H*"B`@("`@("`@("`@("`@("`@("`@8V]L;W)S("!F;W(@(
  1677. XM('!L;W1S("!W:71H("!M=6QT:7!L92`@8W5R=F5S(&EF('1H:7,*("`@("`@C
  1678. XM("`@("`@("`@("`@("!F96%T=7)E("!I<R`@<W5P<&]R=&5D("!F;W(@(&$@V
  1679. XM('!A<G1I8W5L87(@(&]U='!U=`H@("`@("`@("`@("`@("`@("`@(&1E=FEC=
  1680. XM92X@(`H*("`@("`@("`@()LQ;4QI;F53='EL99LP;3U;()LS;7-E="";,&U=E
  1681. XM(`H@("`@("`@("`@("`@("`@("`@()LS;4QI;F53='EL92`@FS!M;6%Y("!B?
  1682. XM92`@=7-E9"!T;R!S<&5C:69Y(&$@;&ES="!O9B!L:6YE"B`@("`@("`@("`@P
  1683. XM("`@("`@("`@<W1Y;&5S(&9O<B`@<&QO=',@('=I=&@@(&UU;'1I<&QE("!CH
  1684. XM=7)V97,N("`@($5A8V@*("`@("`@("`@("`@("`@("`@("!L:6YE<W1Y;&4@7
  1685. XM(&ES("!S<&5C:69I960@(&%S("!A("!S97%U96YC92`@;V8@('!E;@H@("`@8
  1686. XM("`@("`@("`@("`@("`@(&1O=VXN+BX@('!E;B`@=7`@(&5L96UE;G1S+B`@U
  1687. XM("!4:&4@(&5L96UE;G1S("`@87)E"B`@("`@("`@("`@("`@("`@("`@96YC6
  1688. XM;V1E9"!U<VEN9R!T:&4@9F]L;&]W:6YG(&-H87)A8W1E<G,@=&\@:6YD:6-A_
  1689. XM=&4*("`@("`@("`@("`@("`@("`@("!E;&5M96YT(&QE;F=T:',Z(`H@("`@&
  1690. XM("`@("`@("`@("`@("`@("`@("`@("`@("";,6UMFS!M.B`R-3`@;6EC<F]NW
  1691. XM(&UA<FL@"B`@("`@("`@("`@("`@("`@("`@("`@("`@("`@()LQ;4V;,&TZM
  1692. XM(#%M;2!M87)K("B;,6UM;6UMFS!M*2`*("`@("`@("`@("`@("`@("`@("`@6
  1693. XM("`@("`@("`@FS%M<YLP;3H@,C4P(&UI8W)O;B!S<&%C92`*("`@("`@("`@3
  1694. XM("`@("`@("`@("`@("`@("`@("`@FS%M4YLP;3H@,6UM('-P86-E("B;,6USI
  1695. XM<W-SFS!M*2`*("`@("`@("`@("`@("`@("`@("!&;W(@(&5X86UP;&4L("!A$
  1696. XM("!S970@(&]F("!L:6YE("!S='EL97,@(&UI9VAT("!B90H@("`@("`@("`@7
  1697. XM("`@("`@("`@(&EN9&EC871E9"`*("`@("`@("`@("`@("`@("`@("`@("`@/
  1698. XM("`@("`@3&EN95-T>6QE/7M-4RQ-35-3+$U-4VUM4RQM;5,L;6U3;6U334U3O
  1699. XM?2`*"B`@("`@("`@("";,6U/<FEE;G1A=&EO;ILP;3U;()LQ;7!O<G1R86ET4
  1700. XM()LP;7P@FS%M;&%N9'-C87!E()LP;5T@"B`@("`@("`@("`@("`@("`@("`@W
  1701. XMFS-M3W)I96YT871I;VX@FS!M8V]N=')O;',@=VAE=&AE<B!T:&4@<&QO="!IS
  1702. XM<R!D:7-P;&%Y960*("`@("`@("`@("`@("`@("`@("!I;B!L86YD<V-A<&4@>
  1703. XM;W(@<&]R=')A:70@;W)I96YT871I;VXN("`*"B`@("`@("`@("";,6U/<FEG.
  1704. XM:6Z;,&T]6R";,VUI;G1E<G9A;"";,&U\()LQ;4%U=&]M871I8R";,&U\()LQ[
  1705. XM;4UE9&EA;B";,&U=(`H@("`@("`@("`@("`@("`@("`@()LS;4]R:6=I;B";X
  1706. XM,&UA;&QO=W,@=&AE('!L86-E;65N="!O9B!A('-E="!O9B!A>&5S(&%T(&%NU
  1707. XM"B`@("`@("`@("`@("`@("`@("`@87)B:71R87)Y('!O:6YT+B`@5&AE()LSA
  1708. XM;4UE9&EA;B";,&UV86QU92!P;&%C97,@=&AE(&%X97,*("`@("`@("`@("`@$
  1709. XM("`@("`@("!A="!T:&4@;65D:6%N()LS;5@@FS!M86YD("!T:&4@(&UE9&EA#
  1710. XM;B`@FS-M62`@FS!M;V8@('1H92`@9&%T80H@("`@("`@("`@("`@("`@("`@4
  1711. XM('9A;'5E<RX@(`H*("`@("`@("`@()LQ;5!L;W1#;VQO<ILP;3U;()LS;6)O%
  1712. XM;VQE86X@FS!M72`*("`@("`@("`@("`@("`@("`@("";,VU0;&]T0V]L;W(@G
  1713. XM()LP;6EF()LQ;71R=64@FS!M8V%U<V5S('1H92!P;&]T('1O(&=E;F5R871E*
  1714. XM9"!I;@H@("`@("`@("`@("`@("`@("`@(&-O;&]R(&EF('1H:7,@9F5A='5RR
  1715. XM92!I<R!S=7!P;W)T960@;VX@82!P87)T:6-U;&%R"B`@("`@("`@("`@("`@&
  1716. XM("`@("`@;W5T<'5T(&1E=FEC92X@(`H*("`@("`@("`@()LQ;5!L;W1*;VENK
  1717. XM962;,&T]6R";,VUB;V]L96%N()LP;5T@"B`@("`@("`@("`@("`@("`@("`@S
  1718. XMFS-M4&QO=$IO:6YE9"P@FS!M:68@<V5T+"!C;VYN96-T<R!E86-H(&1A=&$@F
  1719. XM<&]I;G0@('=I=&@*("`@("`@("`@("`@("`@("`@("!A(&QI;F4@:6X@=&AEQ
  1720. XM(&-U<G)E;G0@;&EN92!S='EL92X@(`H*("`@("`@("`@()LQ;5!L;W10;VENL
  1721. XM='.;,&T]6R";,VUB;V]L96%N()LP;5T@"B`@("`@("`@("`@("`@("`@("`@1
  1722. XMFS-M4&QO=%!O:6YT<R";,&UI9B";,6UT<G5E()LP;6-A=7-E<R!S>6UB;VQS<
  1723. XM('1O(&)E('!L;W1T960@:6X*("`@("`@("`@("`@("`@("`@("!T:&4@8W5RR
  1724. XM<F5N="!S>6UB;VP@<W1Y;&4@870@96%C:"!D871A('!O:6YT+B`@"@H@("`@L
  1725. XM("`@("`@FS%M4&]I;G138V%L99LP;3U;()LS;61B;"";,&U=(`H@("`@("`@'
  1726. XM("`@("`@("`@("`@()LS;5!O:6YT4V-A;&4@()LP;6-O;G1R;VQS('1H92!RL
  1727. XM96QA=&EV92!S:7IE(&]F('1H92!D871A"B`@("`@("`@("`@("`@("`@("`@?
  1728. XM<&]I;G0@<WEM8F]L<R!W:&5N(&1A=&$@<&]I;G0@('-Y;6)O;',@(&%R92`@J
  1729. XM8F5I;F<*("`@("`@("`@("`@("`@("`@("!P;&]T=&5D+B`@"@H@("`@("`@M
  1730. XM("`@FS%M4&]I;G13>6UB;VR;,&T]6R";,6U!=71O;6%T:6,@FS!M?"";,VUS+
  1731. XM970@FS!M72`*("`@("`@("`@("`@("`@("`@("";,VU0;VEN=%-Y;6)O;"";N
  1732. XM,&US<&5C:69I97,@82!L:7-T(&]F('-Y;6)O;',@=&\@8F4@=7-E9`H@("`@8
  1733. XM("`@("`@("`@("`@("`@('=H96X@<&QO='1I;F<@(&1A=&$@<&]I;G1S+B`@(
  1734. XM5&AE('-Y;6)O;',@='EP97,@87)E"B`@("`@("`@("`@("`@("`@("`@96YCW
  1735. XM;V1E9"!A<R!I;G1E9V5R<RX@("`@*%-E92`@=&AE("";,6U03%!,3U0@()LPD
  1736. XM;6QI8G)A<GD*("`@("`@("`@("`@("`@("`@("!D;V-U;65N=&%T:6]N('1OI
  1737. XM(&9I;F0@=&AE('-Y;6)O;',@879A:6QA8FQE+BD@"@H@("`@("`@("`@FS%M0
  1738. XM4&QO=%1I=&QEFS!M/5L@*B!=(`H@("`@("`@("`@("`@("`@("`@()LS;5!L9
  1739. XM;W14:71L92`@FS!M=&%K97,@('1H92`@<&QO="`@=&ET;&4@87,@86X@87)G4
  1740. XM=6UE;G0N"B`@("`@("`@("`@("`@("`@("`@5&5X="!C;VYT<F]L("!S97%UE
  1741. XM96YC97,@(&1E<V-R:6)E9"`@86)O=F4@(&UA>2`@8F4*("`@("`@("`@("`@8
  1742. XM("`@("`@("!I;F-L=61E9"X@(`H*"@H@("`@(#4O,34O.3`@("`@("`@("`@@
  1743. XM("`@("`@("`@("`@("`@("TS+2`@("`@("`@("`@("`@("`@("!$=6ME(%5N9
  1744. XM:79E<G-I='D*"@H@("`@($QI<W10;&]T*#$I("`@("`@("`@("`@("`@("`@Z
  1745. XM04U)1T$@36%N=6%L("`@("`@("`@("`@("`@("`@3&ES=%!L;W0H,2D*"@H@8
  1746. XM("`@("`@("`@FS%M4&QO=$1E=FEC99LP;3U;FS%M86UI9V&;,&U\()LQ;7!R_
  1747. XM:6YT97(@FS!M?"";,6UI9F8@FS!M?"";,6UH<"";,&U\()LQ;6%E9VES()LPJ
  1748. XM;7P@FS%M<&]S='-C<FEP=)LP;5T@"B`@("`@("`@("`@("`@("`@("`@FS-M7
  1749. XM4&QO=$1E=FEC92";,&US<&5C:69I97,@;W5T<'5T(&1E=FEC92!T>7!E+B`@S
  1750. XM"@H@("`@("`@("`@FS%M4&QO=%1Y<&6;,&T]6R";,6UL:6YL:6X@FS!M?"";,
  1751. XM,6UL;V=L:6X@FS!M?"";,6UL:6YL;V<@FS!M?"";,6UL;V=L;V<@FS!M?"";5
  1752. XM,6UP;VQA<B";,&U=(`H@("`@("`@("`@("`@("`@("`@()LS;5!L;W14>7!E7
  1753. XM("";,&US<&5C:69I97,@=&AE()LS;6=R87!H('!A<&5R()LP;75P;VX@=VAI[
  1754. XM8V@@=&AE"B`@("`@("`@("`@("`@("`@("`@<&QO="!I<R!D<F%W;BX@(%1H7
  1755. XM92!C=7)R96YT("!I;7!L96UE;G1A=&EO;B`@<&QO=',*("`@("`@("`@("`@J
  1756. XM("`@("`@("!I;B`*("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@;&EN$
  1757. XM96%R+6QI;F5A<BP@"B`@("`@("`@("`@("`@("`@("`@("`@("`@("`@(&QO1
  1758. XM9RUL:6YE87(L(`H@("`@("`@("`@("`@("`@("`@("`@("`@("`@("!L:6YE-
  1759. XM87(M;&]G+"`*("`@("`@("`@("`@("`@("`@("`@("`@("`@("`@;&]G+6QOB
  1760. XM9RP@86YD(`H@("`@("`@("`@("`@("`@("`@("`@("`@("`@("!P;VQA<B`*8
  1761. XM"B`@("`@("`@("`@("`@("`@("`@9F]R;6%T<RX@("!&;W(@('1H92!L;V<@^
  1762. XM='EP92!P;&]T<RP@=&AE(&QO9R!O9B!T:&4*("`@("`@("`@("`@("`@("`@C
  1763. XM("!D871A(&ES(&-O;7!U=&5D+B`@("!&;W(@('!O;&%R("!P;&]T<RP@('-E`
  1764. XM92`@86QS;PH@("`@("`@("`@("`@("`@("`@()LS;4%N9W5L87)5;FET()LPN
  1765. XM;6%N9"";,VU0;VQA<E9A<FEA8FQE+B`*"B`@("`@("`@("";,&V;,6U0;VQA^
  1766. XM<E9A<FEA8FQEFS!M/5L@FS%M86YG;&4@FS!M?"";,6UR861I=7,@FS!M72`*<
  1767. XM("`@("`@("`@("`@("`@("`@("";,VU0;VQA<E9A<FEA8FQE("";,&UF;W(@^
  1768. XM('!O;&%R('!L;W1S(&ES('5S960@=&\@<W!E8VEF>0H@("`@("`@("`@("`@=
  1769. XM("`@("`@('=H971H97(@=&AE(&EN9&5P96YD96YT("!V87)I86)L92`@:7,@H
  1770. XM(&%N9W5L87(@(&]R"B`@("`@("`@("`@("`@("`@("`@<F%D:6%L+B`@"@H@$
  1771. XM("`@("`@("`@FS%M4F%N9V6;,&T]6R";,VUI;G1E<G9A;"";,&U\()LQ;4%LP
  1772. XM;"";,&U\()LQ;4%U=&]M871I8R";,&U=(`H@("`@("`@("`@("`@("`@("`@_
  1773. XM()LS;5)A;F=E()LP;7-P96-I9FEE<R`@('1H92`@('D@("!A>&ES("`@8F]U0
  1774. XM;F1S+B`@("`H97@N"B`@("`@("`@("`@("`@("`@("`@4F%N9V4]+3$L,2`I>
  1775. XM(%=H96X@('-E="`@=&\@()LQ;4%L;)LP;2P@(&%L;"`@<&]I;G1S("!A<F4*O
  1776. XM("`@("`@("`@("`@("`@("`@("!P;&]T=&5D+B`@(%=H96X@('-E="!T;R";F
  1777. XM,6U!=71O;6%T:6.;,&TL(&]U=&QY:6YG('!O:6YT<PH@("`@("`@("`@("`@K
  1778. XM("`@("`@(&UA>2!N;W0@8F4@<&QO='1E9"X@(`H*("`@("`@("`@()LQ;5-U>
  1779. XM8E!A9V5SFS!M/5L@FS-M:6YT97)V86P@FS!M72`*("`@("`@("`@("`@("`@A
  1780. XM("`@("";,VU3=6)086=E<R`@FS!M<W!E8VEF:65S("!T:&4@(&YU;6)E<B`@R
  1781. XM;V8@('!L;W1S("!O;B`@80H@("`@("`@("`@("`@("`@("`@('!A9V5S+B`@-
  1782. XM(%1H:7,@(&ES(&$@=F5S=&EG92!O9B!03%!,3U0@86YD($D@86T@;F]T"B`@!
  1783. XM("`@("`@("`@("`@("`@("`@<W5R92!T:&ES("!H87,@(&%N>2`@=7-E("!W?
  1784. XM:71H:6X@('1H92`@8V]N=&5X="`@;V8*("`@("`@("`@("`@("`@("`@("";<
  1785. XM,VU,:7-T4&QO="X@()LP;4ET("!M:6=H="!B92!U<V5F=6P@9F]R(&-O;G1R?
  1786. XM;VQL:6YG('1H90H@("`@("`@("`@("`@("`@("`@('-I>F4@;V8@=&AE('!L]
  1787. XM;W1S(&)U="!T:&4@FS-M5FEE=U!O<G0@FS!M;6EG:'0@8F4@82!M;W)E"B`@S
  1788. XM("`@("`@("`@("`@("`@("`@9&ER96-T('-O;'5T:6]N+B`@"@H@("`@("`@Z
  1789. XM("`@FS%M4W5P<&QY06)S8VES<V&;,&T]6R";,VUB;V]L96%N()LP;5T@"B`@Y
  1790. XM("`@("`@("`@("`@("`@("`@FS-M4W5P<&QY06)S8VES<V$@FS!M:68@<V5T$
  1791. XM(&-A=7-E<R";,VU,:7-T4&QO="";,&UT;R!S=7!P;'D@(&$*("`@("`@("`@-
  1792. XM("`@("`@("`@("!V86QU92!F;W(@=&AE(&EN9&5P96YD96YT('9A<FEA8FQE9
  1793. XM+B`@"@H@("`@("`@("`@FS%M5&ET;&538V%L99LP;3U;()LS;61B;"";,&U=W
  1794. XM(`H@("`@("`@("`@("`@("`@("`@()LS;51I=&QE4V-A;&4@FS!M8V]N=')O\
  1795. XM;',@=&AE(')E;&%T:79E('-I>F4@;V8@=&AE('1I=&QE"B`@("`@("`@("`@9
  1796. XM("`@("`@("`@=&5X="X@(`H*("`@("`@("`@()LQ;55S94EN<'5T1FEL99LPH
  1797. XM;3U;("H@72`*("`@("`@("`@("`@("`@("`@("";,VU5<V5);G!U=$9I;&4@.
  1798. XMFS!M<&5R;6ET<R!T:&4@<W!E8VEF:6-A=&EO;B!O9B!A;B!I;G!U=`H@("`@<
  1799. XM("`@("`@("`@("`@("`@(&9I;&4@:68@>6]U('=O=6QD(')A=&AE<B!N;W0@.
  1800. XM=7-E('-T9&EN+B`@"@H@("`@("`@("`@FS%M57-E3W5T<'5T1FEL99LP;3U;8
  1801. XM("H@72`*("`@("`@("`@("`@("`@("`@("";,VU5<V5/=71P=71&:6QE("";%
  1802. XM,&UP97)M:71S("!T:&4@('-P96-I9FEC871I;VX@(&]F("!A;@H@("`@("`@1
  1803. XM("`@("`@("`@("`@(&]U='!U="!F:6QE(&EF('EO=2!W;W5L9"!R871H97(@.
  1804. XM;F]T('5S92!S=&1O=70N("`*"B`@("`@("`@("";,6U697)B;W-EFS!M/5L@"
  1805. XMFS-M8F]O;&5A;B";,&U=(`H@("`@("`@("`@("`@("`@("`@()LS;59E<F)OS
  1806. XM<V4@FS!M:68@<V5T(&-A=7-E<R!E>'1E;F1E9"!M97-S86=I;F<N("`*"B`@@
  1807. XM("`@("`@("";,6U6:65W4&]R=)LP;3U;()LS;7)E8W0@FS!M72`*("`@("`@Q
  1808. XM("`@("`@("`@("`@("";,VU6:65W4&]R="";,&UA;&QO=W,@8V]N=')O;"!O5
  1809. XM=F5R('1H92!S:7IE(&]F("!A("!P;&]T+@H@("`@("`@("`@("`@("`@("`@V
  1810. XM(%1A:V5S("`@82`@('9I97=I;F<@("!R96-T86YG;&4@("!D:6%G;VYA;"`@F
  1811. XM87,@(&%N"@H*("`@("`U+S$U+SDP("`@("`@("`@("`@("`@("`@("`@("`@#
  1812. XM("`M-"T@("`@("`@("`@("`@("`@("`@1'5K92!5;FEV97)S:71Y"@H*("`@7
  1813. XM("!,:7-T4&QO="@Q*2`@("`@("`@("`@("`@("`@($%-24=!($UA;G5A;"`@:
  1814. XM("`@("`@("`@("`@("`@($QI<W10;&]T*#$I"@H*("`@("`@("`@("`@("`@[
  1815. XM("`@("!A<F=U;65N="X@(`H@("`@("`@("`@("`@("`@("`@("`@("`@("`@[
  1816. XM("!E>"X@(%9I97=0;W)T/7LP+C$L,"XS+"`P+CDL,"XV?2`*"B`@("`@("`@C
  1817. XM("";,6U83&%B96R;,&T]6R`J(%T@"B`@("`@("`@("`@("`@("`@("`@FS-MM
  1818. XM6$QA8F5L()LP;7-P96-I9FEE<R`@6"`@87AI<R`@;&%B96PN("`@(%1E>'0@+
  1819. XM(&-O;G1R;VP*("`@("`@("`@("`@("`@("`@("!S97%U96YC97,@9&5S8W)I1
  1820. XM8F5D(&%B;W9E(&UA>2!B92!I;F-L=61E9"X@(`H*("`@("`@("`@()LQ;5E,N
  1821. XM86)E;)LP;3U;("H@72`*("`@("`@("`@("`@("`@("`@("";,VU93&%B96P@I
  1822. XMFS!M<W!E8VEF:65S("!9("!A>&ES("!L86)E;"X@("`@5&5X="`@8V]N=')OI
  1823. XM;`H@("`@("`@("`@("`@("`@("`@('-E<75E;F-E<R!D97-C<FEB960@86)O9
  1824. XM=F4@;6%Y(&)E(&EN8VQU9&5D+B`@"@H@("`@("`@("`@FS%M6%1I8VN;,&T]D
  1825. XM6R";,6U!=71O;6%T:6,@FS!M?"";,VUI;G1E<G9A;"";,&U=(`H@("`@("`@N
  1826. XM("`@("`@("`@("`@()LS;5A4:6-K()LP;6-O;G1R;VQS('1H92!S<&%C:6YGP
  1827. XM(&]F(&UA:F]R(&%X:7,@=&EC:W,@86YD"B`@("`@("`@("`@("`@("`@("`@>
  1828. XM=&AE(&YU;6)E<B`@(&]F("`@;6EN;W(@("!S=6)D:79I<VEO;G,N("`@("`@4
  1829. XM("AE>"X*("`@("`@("`@("`@("`@("`@("";,VU85&EC:STP+C$L,3`@FS!ML
  1830. XM:6YD:6-A=&5S(&UA:F]R('1I8VMS(&%T('5N:71S(&]F(#`N,0H@("`@("`@!
  1831. XM("`@("`@("`@("`@('=I=&@@,3`@;6EN;W(@<W5B9&EV:7-I;VYS+BD@"@H@/
  1832. XM("`@("`@("`@FS%M651I8VN;,&T]6R";,6U!=71O;6%T:6,@FS!M?"";,VU)%
  1833. XM;G1E<G9A;"";,&U=(`H@("`@("`@("`@("`@("`@("`@()LS;5E4:6-K()LPE
  1834. XM;6-O;G1R;VQS('1H92!S<&%C:6YG(&]F(&UA:F]R(&%X:7,@=&EC:W,@86YD;
  1835. XM"B`@("`@("`@("`@("`@("`@("`@=&AE(&YU;6)E<B!O9B!M:6YO<B!S=6)D\
  1836. XM:79I<VEO;G,N("`*"B`@("`@FS%M1DE,15,@"@H@("`@($E$14Y4249)0T%4Z
  1837. XM24].(`H@("`@("`@("`@FS!M075T:&]R<SH@($9R961E<FEC:R`@4BX@($)A:
  1838. XM<G1R86T@(&%N9"!!;G1H;VYY($TN(%)I8VAA<F1S;VXL"B`@("`@("`@("!$<
  1839. XM97!T+B!O9B!%;&5C=')I8V%L($5N9VEN965R:6YG+"`@1'5K92`@56YI=F5R]
  1840. XM<VET>2P@($1U<FAA;2P*("`@("`@("`@($XN0RX@,C<W,#8N("`*("`@("`@7
  1841. XM("`@($EN=&5R3F5T.B!F<F)`9'5K964N96=R+F1U:V4N961U+&%M<D!D=6ME/
  1842. XM92YE9W(N9'5K92YE9'4@"B`@("`@("`@("!#;W!Y<FEG:'0@(#$Y.3`@(&)YE
  1843. XM("!&<F5D97)I8VL@(%(N("!"87)T<F%M("!A;F0@($%N=&AO;GD@32X*("`@Q
  1844. XM("`@("`@(%)I8VAA<F1S;VXN("`*("`@("`@("`@($%M:6=A('!O<G0@8GD@$
  1845. XM06YT:&]N>2!-+B!2:6-H87)D<V]N(`H*("`@("";,6U"54=3(`H@("`@("`@Q
  1846. XM("`@FS!M4&QE87-E(')E<&]R="!A;GD@8G5G<R!O<B!U;G5S=6%L()LS;69E[
  1847. XM871U<F5S()LP;71O('1H92!A=71H;W)S+B`@"@H*"@H*"@H*"@H*"@H*"@H*X
  1848. XM"@H*"@H*"@H*("`@("`U+S$U+SDP("`@("`@("`@("`@("`@("`@("`@("`@<
  1849. XI("`M-2T@("`@("`@("`@("`@("`@("`@1'5K92!5;FEV97)S:71Y"@H@.
  1850. X``
  1851. Xend
  1852. Xsize 13631
  1853. END_OF_FILE
  1854. if test 19126 -ne `wc -c <'docs/ListPlot.uu'`; then
  1855.     echo shar: \"'docs/ListPlot.uu'\" unpacked with wrong size!
  1856. fi
  1857. # end of 'docs/ListPlot.uu'
  1858. fi
  1859. echo shar: End of archive 2 \(of 3\).
  1860. cp /dev/null ark2isdone
  1861. MISSING=""
  1862. for I in 1 2 3 ; do
  1863.     if test ! -f ark${I}isdone ; then
  1864.     MISSING="${MISSING} ${I}"
  1865.     fi
  1866. done
  1867. if test "${MISSING}" = "" ; then
  1868.     echo You have unpacked all 3 archives.
  1869.     rm -f ark[1-9]isdone
  1870. else
  1871.     echo You still need to unpack the following archives:
  1872.     echo "        " ${MISSING}
  1873. fi
  1874. ##  End of shell archive.
  1875. exit 0
  1876. -- 
  1877. Mail submissions (sources or binaries) to <amiga@uunet.uu.net>.
  1878. Mail comments to the moderator at <amiga-request@uunet.uu.net>.
  1879. Post requests for sources, and general discussion to comp.sys.amiga.
  1880.